API Reference

new StarkZap(config: SDKConfig): StarkZap

interface SDKConfig {
  network?: NetworkName | NetworkPreset;
  rpcUrl?: string;
  chainId?: ChainId;
  paymaster?: PaymasterOptions; // { nodeUrl?: string; default?: boolean; headers?: object }
  explorer?: ExplorerConfig;
  staking?: StakingConfig;
  bridging?: BridgingConfig;
}

interface ConnectWalletOptions {
  account: AccountConfig;
  accountAddress?: Address;
  feeMode?: FeeMode;
  timeBounds?: PaymasterTimeBounds;
  swapProviders?: SwapProvider[];
  defaultSwapProviderId?: string;
  dcaProviders?: DcaProvider[];
  defaultDcaProviderId?: string;
}

interface AccountConfig {
  signer: SignerInterface;
  accountClass?: AccountClassConfig;
}

new StarkSigner(privateKey: string): StarkSigner

new PrivySigner(config: {
  walletId: string;
  publicKey: string;
  serverUrl?: string;
  rawSign?: (walletId: string, hash: string) => Promise<string>;
}): PrivySigner

interface SignerInterface {
  getPubKey(): Promise<string>;
  signRaw(hash: string): Promise<Signature>;
}

type Address = string & { readonly __type: "StarknetAddress" };

// Create from BigNumberish (string, number, or bigint)
fromAddress(value: BigNumberish): Address

class ChainId {
  static MAINNET: ChainId;
  static SEPOLIA: ChainId;
  
  static from(literal: ChainIdLiteral): ChainId;
  static fromFelt252(felt: string): ChainId;
  
  isMainnet(): boolean;
  isSepolia(): boolean;
  toFelt252(): string;
  toLiteral(): ChainIdLiteral;
}

type FeeMode = "sponsored" | "user_pays";

type DeployMode = "never" | "if_needed" | "always";

const OnboardStrategy = {
  Signer: "signer",
  Privy: "privy",
  Cartridge: "cartridge",
} as const;

type OnboardStrategy = (typeof OnboardStrategy)[keyof typeof OnboardStrategy];

interface Token {
  name: string;
  address: Address;
  decimals: number;
  symbol: string;
  metadata?: { logoUrl?: URL };
}

interface BridgingConfig {
  layerZeroApiKey?: string; // required for OFT/OFT-migrated routes
  ethereumRpcUrl?: string;
  solanaRpcUrl?: string;
}

enum ExternalChain {
  ETHEREUM = "ethereum",
  SOLANA = "solana",
}

abstract class BridgeToken {
  id: string;
  name: string;
  symbol: string;
  decimals: number;
  chain: ExternalChain;
  protocol: Protocol;
  address: ExternalAddress;      // source-chain token
  bridgeAddress: ExternalAddress; // source-chain bridge
  starknetAddress: Address;      // destination token on Starknet
  starknetBridge: Address;       // destination bridge contract
}
// Concrete subclasses: EthereumBridgeToken, SolanaBridgeToken

ConnectedEthereumWallet.from(
  {
    chain: ExternalChain.ETHEREUM,
    provider: eip1193Provider,
    address: "0x...",
    chainId: "0x1",
  },
  starknetChainId
);

ConnectedSolanaWallet.from(
  {
    chain: ExternalChain.SOLANA,
    provider: solanaProvider,
    address: "So1...",
    chainId: "<solana-genesis-hash>",
  },
  starknetChainId
);

interface Pool {
  poolContract: Address;
  token: Token;
  amount: Amount;
}

interface PoolMember {
  staked: Amount;
  rewards: Amount;
  total: Amount;
  unpooling: Amount;
  unpoolTime: Date | null;
  commissionPercent: number;
  rewardAddress: Address;
}

interface Validator {
  name: string;
  stakerAddress: Address;
  logoUrl: URL | null;
}

interface PreflightResultOk { ok: true }
interface PreflightResultError { ok: false; reason: string }
type PreflightResult = PreflightResultOk | PreflightResultError;

import { mainnetTokens, sepoliaTokens } from "starkzap";

// Access tokens
const STRK = mainnetTokens.STRK;
const USDC = mainnetTokens.USDC;

import { mainnetValidators, sepoliaValidators } from "starkzap";

// Access validators
for (const validator of Object.values(mainnetValidators)) {
  console.log(validator.name);
}

import {
  OpenZeppelinPreset,
  ArgentPreset,
  ArgentXV050Preset,
  BraavosPreset,
  DevnetPreset,
} from "starkzap";

fromAddress(value: BigNumberish): Address

getChainId(provider: RpcProvider): Promise<ChainId>

getPresets(chainId: ChainId): Record<string, Token>

getTokensFromAddresses(
  addresses: Address[],
  provider: RpcProvider
): Promise<Token[]>