@b3dotfun/sdk 0.0.1-alpha.1

package/dist/esm/anyspend/types/tournament.d.ts

@@ -0,0 +1,174 @@
+import { z } from "zod";
+export declare const zTournament: z.ZodObject<{
+    slug: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    imageUrl: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    imageUrl: string;
+    slug: string;
+}, {
+    name: string;
+    description: string;
+    imageUrl: string;
+    slug: string;
+}>;
+export type Tournament = z.infer<typeof zTournament>;
+export declare const zJoinTournamentPayload: z.ZodObject<{
+    contractAddress: z.ZodString;
+    entryPrice: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    contractAddress: string;
+    entryPrice: string;
+}, {
+    contractAddress: string;
+    entryPrice: string;
+}>;
+export declare const zFundTournamentPayload: z.ZodObject<{
+    contractAddress: z.ZodString;
+    fundAmount: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    contractAddress: string;
+    fundAmount: string;
+}, {
+    contractAddress: string;
+    fundAmount: string;
+}>;
+export declare const zTournamentMetadata: z.ZodObject<{
+    srcToken: z.ZodObject<{
+        chainId: z.ZodNumber;
+        address: z.ZodString;
+        symbol: z.ZodString;
+        name: z.ZodString;
+        decimals: z.ZodNumber;
+        metadata: z.ZodObject<{
+            logoURI: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            logoURI?: string | undefined;
+        }, {
+            logoURI?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        symbol: string;
+        chainId: number;
+        address: string;
+        name: string;
+        decimals: number;
+        metadata: {
+            logoURI?: string | undefined;
+        };
+    }, {
+        symbol: string;
+        chainId: number;
+        address: string;
+        name: string;
+        decimals: number;
+        metadata: {
+            logoURI?: string | undefined;
+        };
+    }>;
+    dstToken: z.ZodObject<{
+        chainId: z.ZodNumber;
+        address: z.ZodString;
+        symbol: z.ZodString;
+        name: z.ZodString;
+        decimals: z.ZodNumber;
+        metadata: z.ZodObject<{
+            logoURI: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            logoURI?: string | undefined;
+        }, {
+            logoURI?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        symbol: string;
+        chainId: number;
+        address: string;
+        name: string;
+        decimals: number;
+        metadata: {
+            logoURI?: string | undefined;
+        };
+    }, {
+        symbol: string;
+        chainId: number;
+        address: string;
+        name: string;
+        decimals: number;
+        metadata: {
+            logoURI?: string | undefined;
+        };
+    }>;
+    tournament: z.ZodObject<{
+        slug: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        imageUrl: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description: string;
+        imageUrl: string;
+        slug: string;
+    }, {
+        name: string;
+        description: string;
+        imageUrl: string;
+        slug: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    srcToken: {
+        symbol: string;
+        chainId: number;
+        address: string;
+        name: string;
+        decimals: number;
+        metadata: {
+            logoURI?: string | undefined;
+        };
+    };
+    dstToken: {
+        symbol: string;
+        chainId: number;
+        address: string;
+        name: string;
+        decimals: number;
+        metadata: {
+            logoURI?: string | undefined;
+        };
+    };
+    tournament: {
+        name: string;
+        description: string;
+        imageUrl: string;
+        slug: string;
+    };
+}, {
+    srcToken: {
+        symbol: string;
+        chainId: number;
+        address: string;
+        name: string;
+        decimals: number;
+        metadata: {
+            logoURI?: string | undefined;
+        };
+    };
+    dstToken: {
+        symbol: string;
+        chainId: number;
+        address: string;
+        name: string;
+        decimals: number;
+        metadata: {
+            logoURI?: string | undefined;
+        };
+    };
+    tournament: {
+        name: string;
+        description: string;
+        imageUrl: string;
+        slug: string;
+    };
+}>;

package/dist/esm/anyspend/types/tournament.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { zToken } from "./token";
+export const zTournament = z.object({
+    slug: z.string(),
+    name: z.string(),
+    description: z.string(),
+    imageUrl: z.string()
+});
+export const zJoinTournamentPayload = z.object({
+    contractAddress: z.string(),
+    entryPrice: z.string()
+});
+export const zFundTournamentPayload = z.object({
+    contractAddress: z.string(),
+    fundAmount: z.string()
+});
+export const zTournamentMetadata = z.object({
+    srcToken: zToken,
+    dstToken: zToken,
+    tournament: zTournament
+});

package/dist/esm/anyspend/types/transaction.d.ts

@@ -0,0 +1,84 @@
+import { z } from "zod";
+export declare const zDepositTransaction: z.ZodObject<{
+    orderId: z.ZodString;
+    chain: z.ZodNumber;
+    from: z.ZodNullable<z.ZodString>;
+    txHash: z.ZodString;
+    amount: z.ZodString;
+    createdAt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    amount: string;
+    createdAt: number;
+    orderId: string;
+    chain: number;
+    from: string | null;
+    txHash: string;
+}, {
+    amount: string;
+    createdAt: number;
+    orderId: string;
+    chain: number;
+    from: string | null;
+    txHash: string;
+}>;
+export type DepositTransaction = z.infer<typeof zDepositTransaction>;
+export declare const zRelayTransaction: z.ZodObject<{
+    orderId: z.ZodString;
+    chain: z.ZodNumber;
+    txHash: z.ZodString;
+    status: z.ZodEnum<["refund", "delayed", "waiting", "failure", "pending", "success"]>;
+    createdAt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    status: "failure" | "success" | "refund" | "delayed" | "waiting" | "pending";
+    createdAt: number;
+    orderId: string;
+    chain: number;
+    txHash: string;
+}, {
+    status: "failure" | "success" | "refund" | "delayed" | "waiting" | "pending";
+    createdAt: number;
+    orderId: string;
+    chain: number;
+    txHash: string;
+}>;
+export type RelayTransaction = z.infer<typeof zRelayTransaction>;
+export declare const zExecuteTransaction: z.ZodObject<{
+    orderId: z.ZodString;
+    chain: z.ZodNumber;
+    txHash: z.ZodString;
+    createdAt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    createdAt: number;
+    orderId: string;
+    chain: number;
+    txHash: string;
+}, {
+    createdAt: number;
+    orderId: string;
+    chain: number;
+    txHash: string;
+}>;
+export type ExecuteTransaction = z.infer<typeof zExecuteTransaction>;
+export declare const zRefundTransaction: z.ZodObject<{
+    orderId: z.ZodString;
+    chain: z.ZodNumber;
+    txHash: z.ZodString;
+    amount: z.ZodString;
+    status: z.ZodEnum<["success", "failure"]>;
+    createdAt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    status: "failure" | "success";
+    amount: string;
+    createdAt: number;
+    orderId: string;
+    chain: number;
+    txHash: string;
+}, {
+    status: "failure" | "success";
+    amount: string;
+    createdAt: number;
+    orderId: string;
+    chain: number;
+    txHash: string;
+}>;
+export type RefundTransaction = z.infer<typeof zRefundTransaction>;

package/dist/esm/anyspend/types/transaction.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { zRelayStatus } from "./relay";
+export const zDepositTransaction = z.object({
+    orderId: z.string(),
+    chain: z.number(),
+    from: z.string().nullable(),
+    txHash: z.string(),
+    amount: z.string(),
+    createdAt: z.number()
+});
+export const zRelayTransaction = z.object({
+    orderId: z.string(),
+    chain: z.number(),
+    txHash: z.string(),
+    status: zRelayStatus,
+    createdAt: z.number()
+});
+export const zExecuteTransaction = z.object({
+    orderId: z.string(),
+    chain: z.number(),
+    txHash: z.string(),
+    createdAt: z.number()
+});
+export const zRefundTransaction = z.object({
+    orderId: z.string(),
+    chain: z.number(),
+    txHash: z.string(),
+    amount: z.string(),
+    status: z.enum(["success", "failure"]),
+    createdAt: z.number()
+});

package/dist/esm/anyspend/utils/address.d.ts

@@ -0,0 +1,4 @@
+export declare function isSolanaAddress(address: string): boolean;
+export declare function isEvmOrSolanaAddress(address: string): boolean;
+export declare function normalizeAddress(address: string): string;
+export declare function eqci(a: string | null | undefined, b: string | null | undefined): boolean;

package/dist/esm/anyspend/utils/address.js

@@ -0,0 +1,23 @@
+import { isAddress } from "viem";
+export function isSolanaAddress(address) {
+    // Solana addresses are 32-byte base58 strings (usually 32-44 characters)
+    const solanaAddressRegex = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
+    return solanaAddressRegex.test(address);
+}
+export function isEvmOrSolanaAddress(address) {
+    return isAddress(address) || isSolanaAddress(address);
+}
+export function normalizeAddress(address) {
+    if (isSolanaAddress(address)) {
+        return address;
+    }
+    return address.toLowerCase(); // EVM address will normalize to lower case
+}
+// Equal case insensitive
+export function eqci(a, b) {
+    if (a === "" && b === "")
+        return true;
+    if (!a || !b)
+        return false;
+    return a.toLowerCase() === b.toLowerCase();
+}

package/dist/esm/anyspend/utils/chain.d.ts

@@ -0,0 +1,25 @@
+import { ChainType, IBaseChain, IEVMChain, ISolanaChain, Token } from "../../anyspend/types";
+import { Account, Chain, PublicClient, Transport, WalletClient } from "viem";
+export declare const EVM_MAINNET: Record<number, IEVMChain>;
+export declare const EVM_TESTNET: Record<number, IEVMChain>;
+export declare const SOLANA_MAINNET: ISolanaChain;
+export declare const EVM_CHAINS: Record<number, IEVMChain>;
+export declare const SOLANA_CHAINS: Record<number, ISolanaChain>;
+export declare const ALL_CHAINS: Record<number, IBaseChain>;
+export declare function getSolanaChains(network: "mainnet" | "testnet"): ISolanaChain;
+export declare function getAllEvmChains(network: "mainnet" | "testnet"): Record<number, IEVMChain>;
+export declare function getChainType(chainId: number): ChainType;
+export declare function chainIdToPublicClient(chainId: number): PublicClient;
+export declare function chainIdToWalletClient(chainId: number, account?: Account): WalletClient<Transport, Chain>;
+export declare function getNativeRequired(chainId: number): bigint;
+export declare function canDepositNative(chainId: number): boolean;
+export declare function isMainnet(chainId: number): boolean;
+export declare function isTestnet(chainId: number): boolean;
+export declare function getDefaultToken(chainId: number): Token;
+export declare function getChainName(chainId: number): string;
+export declare function getPaymentUrl(address: string, amount: bigint, currency: string): string;
+export declare function getExplorerTxUrl(chainId: number, txHash: string): string;
+export declare function getExplorerAddressUrl(chainId: number, address: string): string;
+export declare function getMulticall3Address(chainId: number): string;
+export declare function getNativeToken(chainId: number): Token;
+export declare function isEvmChain(chainId: number): boolean;

package/dist/esm/anyspend/utils/chain.js

@@ -0,0 +1,271 @@
+import { ChainType } from "../../anyspend/types";
+import invariant from "invariant";
+import { createPublicClient, createWalletClient, defineChain, http, parseEther } from "viem";
+import { arbitrum, avalanche, b3, b3Sepolia, base, baseSepolia, bsc, mainnet, optimism, polygon, sepolia } from "viem/chains";
+import { RELAY_SOLANA_MAINNET_CHAIN_ID } from "../../anyspend/constants";
+import { getAvaxToken, getBnbToken, getEthToken, getPolToken, getSolanaToken } from "./token";
+function getCustomEvmChain(chain, rpcUrl) {
+    return defineChain({ ...chain, rpcUrls: { default: { http: [rpcUrl] } } });
+}
+// export const b4testnet = defineChain({
+//   id: 19934,
+//   name: "B4 Testnet",
+//   network: "b4-testnet",
+//   nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+//   rpcUrls: { default: { http: ["https://19934.rpc.thirdweb.com/c2dce731fe7fa39edc1d0ea5a6a5e11e"] } },
+// });
+export const EVM_MAINNET = {
+    [mainnet.id]: {
+        id: mainnet.id,
+        name: mainnet.name,
+        type: ChainType.EVM,
+        logoUrl: "https://assets.relay.link/icons/square/1/light.png",
+        nativeRequired: parseEther("0.001"),
+        canDepositNative: true,
+        defaultToken: getEthToken(mainnet.id),
+        nativeToken: getEthToken(mainnet.id),
+        viem: getCustomEvmChain(mainnet, "https://quick-chaotic-film.quiknode.pro/39a7aae6a7078f9f36c435e6f34c071c641cf863/"),
+        pollingInterval: 4000, // 4 seconds for Ethereum mainnet
+        zapperEnum: "ETHEREUM_MAINNET",
+        coingeckoName: "eth"
+    },
+    [arbitrum.id]: {
+        id: arbitrum.id,
+        name: "Arbitrum",
+        type: ChainType.EVM,
+        logoUrl: "https://assets.relay.link/icons/square/42161/light.png",
+        nativeRequired: parseEther("0.0001"),
+        canDepositNative: true,
+        defaultToken: getEthToken(arbitrum.id),
+        nativeToken: getEthToken(arbitrum.id),
+        viem: getCustomEvmChain(arbitrum, "https://proportionate-twilight-patina.arbitrum-mainnet.quiknode.pro/60e4825626515233a0f566f5915601af6043127b/"),
+        pollingInterval: 500, // 500ms for Arbitrum's fast blocks
+        zapperEnum: "ARBITRUM_MAINNET",
+        coingeckoName: "arbitrum"
+    },
+    [base.id]: {
+        id: base.id,
+        name: base.name,
+        logoUrl: "https://assets.relay.link/icons/square/8453/light.png",
+        type: ChainType.EVM,
+        nativeRequired: parseEther("0.0001"),
+        canDepositNative: true,
+        defaultToken: getEthToken(base.id),
+        nativeToken: getEthToken(base.id),
+        viem: getCustomEvmChain(base, "https://sly-indulgent-bird.base-mainnet.quiknode.pro/4e31fab6845eb29a2764723a43896999fe962e48/"),
+        pollingInterval: 1000, // 1 second for Base
+        zapperEnum: "BASE_MAINNET",
+        coingeckoName: "base"
+    },
+    [optimism.id]: {
+        id: optimism.id,
+        name: optimism.name,
+        logoUrl: "https://assets.relay.link/icons/square/10/light.png",
+        type: ChainType.EVM,
+        nativeRequired: parseEther("0.0001"),
+        canDepositNative: true,
+        defaultToken: getEthToken(optimism.id),
+        nativeToken: getEthToken(optimism.id),
+        viem: getCustomEvmChain(optimism, "https://black-cosmopolitan-hexagon.optimism.quiknode.pro/18382925841f9d09f9e76eef954bf189aa234523/"),
+        pollingInterval: 1000, // 1 second for Optimism
+        zapperEnum: "OPTIMISM_MAINNET",
+        coingeckoName: "optimism"
+    },
+    [polygon.id]: {
+        id: polygon.id,
+        name: polygon.name,
+        logoUrl: "https://assets.relay.link/icons/square/137/light.png",
+        type: ChainType.EVM,
+        nativeRequired: parseEther("0.1"),
+        canDepositNative: true,
+        defaultToken: getPolToken(),
+        nativeToken: getPolToken(),
+        viem: getCustomEvmChain(polygon, "https://purple-young-field.matic.quiknode.pro/ca54f365c1a4c7f970223eb8087e0fc579feba12/"),
+        pollingInterval: 1000, // 1 second for Polygon
+        zapperEnum: "POLYGON_MAINNET",
+        coingeckoName: "polygon"
+    },
+    [avalanche.id]: {
+        id: avalanche.id,
+        name: avalanche.name,
+        logoUrl: "https://assets.relay.link/icons/square/43114/light.png",
+        type: ChainType.EVM,
+        nativeRequired: parseEther("0.005"),
+        canDepositNative: true,
+        defaultToken: getAvaxToken(),
+        nativeToken: getAvaxToken(),
+        viem: getCustomEvmChain(avalanche, "https://burned-billowing-pond.avalanche-mainnet.quiknode.pro/24289978a524a18ef42e568e04fe8cad8c7b6720/ext/bc/C/rpc/"),
+        pollingInterval: 1000, // 1 second for Avalanche
+        zapperEnum: "AVALANCHE_MAINNET",
+        coingeckoName: "avalanche"
+    },
+    [bsc.id]: {
+        id: bsc.id,
+        name: bsc.name,
+        logoUrl: "https://avatars.githubusercontent.com/u/45615063?s=280&v=4",
+        type: ChainType.EVM,
+        nativeRequired: parseEther("0.00001"),
+        canDepositNative: false,
+        defaultToken: getBnbToken(),
+        nativeToken: getBnbToken(),
+        viem: getCustomEvmChain(bsc, "https://bsc-rpc.publicnode.com"),
+        pollingInterval: 1000, // 1 second for BSC
+        zapperEnum: "BSC_MAINNET",
+        coingeckoName: "bsc"
+    },
+    [b3.id]: {
+        id: b3.id,
+        name: b3.name,
+        logoUrl: "https://assets.relay.link/icons/square/8333/light.png",
+        type: ChainType.EVM,
+        nativeRequired: parseEther("0.0001"),
+        canDepositNative: true,
+        defaultToken: getEthToken(b3.id),
+        nativeToken: getEthToken(b3.id),
+        viem: getCustomEvmChain(b3, "https://late-dimensional-yard.b3-mainnet.quiknode.pro/461dbdbd44158cd7a7a764a58ffb01a67eef77f2/"),
+        pollingInterval: 1000, // 1 second for B3
+        zapperEnum: "B3_MAINNET",
+        coingeckoName: "b3"
+    }
+};
+export const EVM_TESTNET = {
+    [sepolia.id]: {
+        id: sepolia.id,
+        name: sepolia.name,
+        logoUrl: "https://assets.relay.link/icons/square/1/light.png",
+        type: ChainType.EVM,
+        nativeRequired: parseEther("0.00001"),
+        canDepositNative: true,
+        defaultToken: getEthToken(sepolia.id),
+        nativeToken: getEthToken(sepolia.id),
+        viem: sepolia,
+        pollingInterval: 1000 // 1 second for Sepolia
+    },
+    [baseSepolia.id]: {
+        id: baseSepolia.id,
+        name: baseSepolia.name,
+        logoUrl: "https://assets.relay.link/icons/square/8453/light.png",
+        type: ChainType.EVM,
+        nativeRequired: parseEther("0.00001"),
+        canDepositNative: true,
+        defaultToken: getEthToken(baseSepolia.id),
+        nativeToken: getEthToken(baseSepolia.id),
+        viem: baseSepolia,
+        pollingInterval: 1000 // 1 second for Base Sepolia
+    },
+    [b3Sepolia.id]: {
+        id: b3Sepolia.id,
+        name: b3Sepolia.name,
+        logoUrl: "https://assets.relay.link/icons/square/8333/light.png",
+        type: ChainType.EVM,
+        nativeRequired: parseEther("0.00001"),
+        canDepositNative: true,
+        defaultToken: getEthToken(b3Sepolia.id),
+        nativeToken: getEthToken(b3Sepolia.id),
+        viem: b3Sepolia,
+        pollingInterval: 1000 // 1 second for B3 Sepolia
+    }
+    // [b4testnet.id]: {
+    //   id: b4testnet.id,
+    //   logoUrl: "https://cdn.b3.fun/b4-logo.png",
+    //   type: ChainType.EVM,
+    //   viem: b4testnet,
+    //   requireNativeBalance: parseEther("0.00001"),
+    //   supportDepositNative: true,
+    // },
+};
+export const SOLANA_MAINNET = {
+    id: RELAY_SOLANA_MAINNET_CHAIN_ID,
+    name: "Solana",
+    logoUrl: "https://assets.relay.link/icons/square/792703809/light.png",
+    type: ChainType.SOLANA,
+    nativeRequired: BigInt(10000000), // 0.01 SOL
+    canDepositNative: true,
+    defaultToken: getSolanaToken(),
+    nativeToken: getSolanaToken()
+};
+export const EVM_CHAINS = { ...EVM_MAINNET, ...EVM_TESTNET };
+export const SOLANA_CHAINS = { [RELAY_SOLANA_MAINNET_CHAIN_ID]: SOLANA_MAINNET };
+export const ALL_CHAINS = { ...EVM_CHAINS, ...SOLANA_CHAINS };
+export function getSolanaChains(network) {
+    invariant(network === "mainnet", "Solana chain is only supported on mainnet");
+    return SOLANA_MAINNET;
+}
+export function getAllEvmChains(network) {
+    return network === "mainnet" ? EVM_MAINNET : EVM_TESTNET;
+}
+export function getChainType(chainId) {
+    invariant(ALL_CHAINS[chainId], `Chain ${chainId} is not supported`);
+    return ALL_CHAINS[chainId].type;
+}
+export function chainIdToPublicClient(chainId) {
+    invariant(EVM_CHAINS[chainId], `Chain ${chainId} is not an EVM chain`);
+    return createPublicClient({
+        chain: EVM_CHAINS[chainId].viem,
+        transport: http(),
+        pollingInterval: EVM_CHAINS[chainId].pollingInterval
+    });
+}
+export function chainIdToWalletClient(chainId, account) {
+    invariant(EVM_CHAINS[chainId], `Chain ${chainId} is not an EVM chain`);
+    return createWalletClient({
+        chain: EVM_CHAINS[chainId].viem,
+        transport: http(),
+        account,
+        pollingInterval: EVM_CHAINS[chainId].pollingInterval
+    });
+}
+export function getNativeRequired(chainId) {
+    invariant(ALL_CHAINS[chainId], `Chain ${chainId} is not supported`);
+    return ALL_CHAINS[chainId].nativeRequired;
+}
+export function canDepositNative(chainId) {
+    invariant(ALL_CHAINS[chainId], `Chain ${chainId} is not supported`);
+    return ALL_CHAINS[chainId].canDepositNative;
+}
+export function isMainnet(chainId) {
+    return EVM_MAINNET[chainId] !== undefined || RELAY_SOLANA_MAINNET_CHAIN_ID === chainId;
+}
+export function isTestnet(chainId) {
+    return EVM_TESTNET[chainId] !== undefined;
+}
+export function getDefaultToken(chainId) {
+    invariant(ALL_CHAINS[chainId], `Chain ${chainId} is not supported`);
+    return ALL_CHAINS[chainId].defaultToken;
+}
+export function getChainName(chainId) {
+    invariant(ALL_CHAINS[chainId], `Chain ${chainId} is not supported`);
+    return EVM_CHAINS[chainId] ? EVM_CHAINS[chainId].viem.name : "Solana";
+}
+export function getPaymentUrl(address, amount, currency) {
+    if (currency === "ETH") {
+        return `ethereum:${address}?value=${amount.toString()}`;
+    }
+    return `ethereum:${address}`;
+}
+export function getExplorerTxUrl(chainId, txHash) {
+    if (EVM_CHAINS[chainId]) {
+        return EVM_CHAINS[chainId].viem.blockExplorers?.default.url + "/tx/" + txHash;
+    }
+    return "https://solscan.io/tx/" + txHash;
+}
+export function getExplorerAddressUrl(chainId, address) {
+    if (EVM_CHAINS[chainId]) {
+        return EVM_CHAINS[chainId].viem.blockExplorers?.default.url + "/address/" + address;
+    }
+    return "https://solscan.io/account/" + address;
+}
+export function getMulticall3Address(chainId) {
+    const chainType = getChainType(chainId);
+    invariant(chainType === ChainType.EVM, "chainType must be EVM");
+    const multicall3 = EVM_CHAINS[chainId].viem.contracts?.multicall3;
+    invariant(multicall3, `multicall3 of chain ${chainId} undefined`);
+    return multicall3.address;
+}
+export function getNativeToken(chainId) {
+    invariant(ALL_CHAINS[chainId], `Chain ${chainId} undefined`);
+    return ALL_CHAINS[chainId].nativeToken;
+}
+export function isEvmChain(chainId) {
+    return Boolean(EVM_CHAINS[chainId]);
+}

package/dist/esm/anyspend/utils/format.d.ts

@@ -0,0 +1,6 @@
+import { Order } from "../../anyspend/types";
+export declare const getStatusDisplay: (order: Order) => {
+    text: string;
+    status: "processing" | "success" | "failure";
+};
+export declare const getErrorDisplay: (errorDetails: string) => string;