API Reference

new StarkZap(config: SDKConfig): StarkZap

interface SDKConfig {
  network?: NetworkName | NetworkPreset;
  rpcUrl?: string;
  chainId?: ChainId;
  paymaster?: { nodeUrl: string };
  explorer?: ExplorerConfig;
  staking?: StakingConfig;
}

new StarkSigner(privateKey: string): StarkSigner

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

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

type Address = string & { __brand: "Address" };

// Create from string
fromAddress(value: string): 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";

enum OnboardStrategy {
  Privy = "privy",
  Signer = "signer",
  Cartridge = "cartridge",
  WebAuthn = "webauthn", // Reserved
}

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

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

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

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

interface PreflightResult {
  ok: boolean;
  reason?: string;
}

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: string): Address

getChainId(provider: RpcProvider): Promise<ChainId>

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

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