@b3dotfun/sdk 0.0.1-alpha.1

package/src/anyspend/utils/chain.ts

@@ -0,0 +1,342 @@
+import { ChainType, IBaseChain, IEVMChain, ISolanaChain, Token } from "@b3dotfun/sdk/anyspend/types";
+import invariant from "invariant";
+import {
+  Account,
+  Chain,
+  createPublicClient,
+  createWalletClient,
+  defineChain,
+  http,
+  parseEther,
+  PublicClient,
+  Transport,
+  WalletClient
+} from "viem";
+import {
+  arbitrum,
+  avalanche,
+  b3,
+  b3Sepolia,
+  base,
+  baseSepolia,
+  bsc,
+  mainnet,
+  optimism,
+  polygon,
+  sepolia
+} from "viem/chains";
+import { RELAY_SOLANA_MAINNET_CHAIN_ID } from "@b3dotfun/sdk/anyspend/constants";
+import { getAvaxToken, getBnbToken, getEthToken, getPolToken, getSolanaToken } from "./token";
+
+function getCustomEvmChain(chain: Chain, rpcUrl: string): Chain {
+  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: Record<number, IEVMChain> = {
+  [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: Record<number, IEVMChain> = {
+  [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: ISolanaChain = {
+  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: Record<number, IEVMChain> = { ...EVM_MAINNET, ...EVM_TESTNET };
+
+export const SOLANA_CHAINS: Record<number, ISolanaChain> = { [RELAY_SOLANA_MAINNET_CHAIN_ID]: SOLANA_MAINNET };
+
+export const ALL_CHAINS: Record<number, IBaseChain> = { ...EVM_CHAINS, ...SOLANA_CHAINS };
+
+export function getSolanaChains(network: "mainnet" | "testnet"): ISolanaChain {
+  invariant(network === "mainnet", "Solana chain is only supported on mainnet");
+  return SOLANA_MAINNET;
+}
+
+export function getAllEvmChains(network: "mainnet" | "testnet"): Record<number, IEVMChain> {
+  return network === "mainnet" ? EVM_MAINNET : EVM_TESTNET;
+}
+
+export function getChainType(chainId: number): ChainType {
+  invariant(ALL_CHAINS[chainId], `Chain ${chainId} is not supported`);
+  return ALL_CHAINS[chainId].type;
+}
+
+export function chainIdToPublicClient(chainId: number): PublicClient {
+  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: number, account?: Account): WalletClient<Transport, Chain> {
+  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: number): bigint {
+  invariant(ALL_CHAINS[chainId], `Chain ${chainId} is not supported`);
+  return ALL_CHAINS[chainId].nativeRequired;
+}
+
+export function canDepositNative(chainId: number): boolean {
+  invariant(ALL_CHAINS[chainId], `Chain ${chainId} is not supported`);
+  return ALL_CHAINS[chainId].canDepositNative;
+}
+
+export function isMainnet(chainId: number): boolean {
+  return EVM_MAINNET[chainId] !== undefined || RELAY_SOLANA_MAINNET_CHAIN_ID === chainId;
+}
+
+export function isTestnet(chainId: number): boolean {
+  return EVM_TESTNET[chainId] !== undefined;
+}
+
+export function getDefaultToken(chainId: number): Token {
+  invariant(ALL_CHAINS[chainId], `Chain ${chainId} is not supported`);
+  return ALL_CHAINS[chainId].defaultToken;
+}
+
+export function getChainName(chainId: number): string {
+  invariant(ALL_CHAINS[chainId], `Chain ${chainId} is not supported`);
+  return EVM_CHAINS[chainId] ? EVM_CHAINS[chainId].viem.name : "Solana";
+}
+
+export function getPaymentUrl(address: string, amount: bigint, currency: string) {
+  if (currency === "ETH") {
+    return `ethereum:${address}?value=${amount.toString()}`;
+  }
+  return `ethereum:${address}`;
+}
+
+export function getExplorerTxUrl(chainId: number, txHash: string) {
+  if (EVM_CHAINS[chainId]) {
+    return EVM_CHAINS[chainId].viem.blockExplorers?.default.url + "/tx/" + txHash;
+  }
+  return "https://solscan.io/tx/" + txHash;
+}
+
+export function getExplorerAddressUrl(chainId: number, address: string) {
+  if (EVM_CHAINS[chainId]) {
+    return EVM_CHAINS[chainId].viem.blockExplorers?.default.url + "/address/" + address;
+  }
+  return "https://solscan.io/account/" + address;
+}
+
+export function getMulticall3Address(chainId: number): string {
+  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: number): Token {
+  invariant(ALL_CHAINS[chainId], `Chain ${chainId} undefined`);
+  return ALL_CHAINS[chainId].nativeToken;
+}
+
+export function isEvmChain(chainId: number): boolean {
+  return Boolean(EVM_CHAINS[chainId]);
+}

package/src/anyspend/utils/format.ts

@@ -0,0 +1,64 @@
+import { Order, OrderStatus, OrderType } from "@b3dotfun/sdk/anyspend/types";
+
+export const getStatusDisplay = (order: Order): { text: string; status: "processing" | "success" | "failure" } => {
+  switch (order.status) {
+    case OrderStatus.ScanningDepositTransaction:
+      return {
+        text: order.onrampMetadata ? "Awaiting Payment" : "Awaiting Deposit",
+        status: "processing"
+      };
+    case OrderStatus.WaitingStripePayment:
+      return {
+        text: "Awaiting Payment",
+        status: "processing"
+      };
+
+    case OrderStatus.ObtainToken:
+      return { text: "Obtaining Token", status: "processing" };
+    case OrderStatus.ObtainFailed:
+      return { text: "Obtain Token Failed", status: "failure" };
+
+    case OrderStatus.Expired:
+      return { text: "Order Expired", status: "failure" };
+
+    case OrderStatus.SendingTokenFromVault:
+      return { text: "Sending Token", status: "processing" };
+
+    case OrderStatus.Relay:
+      return { text: "Executing Order", status: "processing" };
+    case OrderStatus.Executed: {
+      const text =
+        order.type === OrderType.Swap
+          ? "Swap Complete"
+          : order.type === OrderType.MintNFT
+            ? "NFT Minted"
+            : order.type === OrderType.JoinTournament
+              ? "Tournament Joined"
+              : order.type === OrderType.FundTournament
+                ? "Tournament Funded"
+                : "Order Complete";
+      return { text, status: "success" };
+    }
+
+    case OrderStatus.Refunding:
+      return { text: "Order Refunding", status: "processing" };
+    case OrderStatus.Refunded:
+      return { text: "Order Refunded", status: "failure" };
+
+    case OrderStatus.Failure:
+      return { text: "Order Failure", status: "failure" };
+
+    default:
+      throw new Error("Invalid order status");
+  }
+};
+
+export const getErrorDisplay = (errorDetails: string): string => {
+  switch (errorDetails) {
+    case "SLIPPAGE":
+      return "The order failed due to price movement exceeding slippage tolerance";
+    default: {
+      return "The order failed. Please try again or contact support";
+    }
+  }
+};

package/src/anyspend/utils/index.ts

@@ -0,0 +1,8 @@
+export * from "./address";
+export * from "./chain";
+export * from "./format";
+export * from "./json";
+export * from "./number";
+export * from "./string";
+export * from "./token";
+export * from "./orderPayload";

package/src/anyspend/utils/json.ts

@@ -0,0 +1,3 @@
+export function stringify(value: any): string {
+  return JSON.stringify(value, (_, v) => (typeof v === "bigint" ? v.toString() : v));
+}

package/src/anyspend/utils/number.ts

@@ -0,0 +1,93 @@
+import Big from "big.js";
+import { parseUnits } from "viem";
+
+// Configure Big.js to use exponential notation only for very large/small numbers
+Big.PE = 40; // Precision for exponential notation (higher = less use of exponential)
+
+// Convert a token amount to a human-readable decimal
+// n = "10000000000000000000", decimals = 9 => "10.0" (10 tokens with 9 decimals)
+export function divpowToBig(n: string | number | bigint, decimals: number): Big {
+  const value = new Big(n.toString());
+  const divisor = new Big(10).pow(decimals);
+  return value.div(divisor);
+}
+
+// Convert a human-readable decimal to a token amount
+// s = "0.000000000000001", multiplier = 18 => 1000 (0.000000000000001 ETH with 18 decimals = 1000 wei)
+export function mulpowToBig(s: string, multiplier = 18): Big {
+  if (!s || s === "") {
+    return new Big(0);
+  }
+
+  // Parse the string into wei/atomic units
+  const atomicUnits = parseUnits(truncateValue(s, multiplier), multiplier).toString();
+  // Return the number of atomic units
+  return new Big(atomicUnits);
+}
+
+export function truncateValue(value: string, decimals: number): string {
+  if (!value || value === "") {
+    return "0";
+  }
+
+  // Special case for decimal-only input
+  if (value === ".") return "0";
+
+  // Handle case where value starts with decimal point
+  if (value.startsWith(".")) {
+    value = "0" + value;
+  }
+
+  const parts = value.split(/\./);
+  if (parts.length > 1) {
+    // Remove leading zeros from whole part
+    parts[0] = parts[0].replace(/^0+(?=\d)/, "");
+    if (parts[0] === "") parts[0] = "0"; // If whole part is empty, set to '0'
+
+    // Limit decimal part to specified number of places
+    parts[1] = parts[1].slice(0, decimals);
+
+    // Remove trailing zeros from decimal part
+    parts[1] = parts[1].replace(/0+$/, "");
+
+    // Special case for very small numbers where all digits get truncated
+    if (parts[1] === "" || parts[1].match(/^0+$/)) {
+      return parts[0];
+    }
+
+    // If the decimal part is empty after processing, return just the whole part
+    if (parts[1] === "") {
+      return parts[0];
+    }
+
+    const res = `${parts[0]}.${parts[1]}`;
+    return res;
+  }
+
+  // For numbers without a decimal part
+  const cleanValue = value.replace(/^0+(?=\d)/, ""); // Remove leading zeros.
+  return cleanValue || "0"; // Return '0' if the result is an empty string
+}
+
+export const inputRegex = RegExp(`^\\d*(?:\\\\[.])?\\d*$`); // match escaped "." characters via in a non-capturing group
+export function escapeRegExp(string: string): string {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
+}
+
+/**
+ * Round up a number to the nearest multiple of 0.01 USDC, which is 10^4 USDC base units
+ * @param value - The number to round up
+ * @returns The rounded number
+ * For example, roundUpUSDCBaseAmountToNearest("2663988") = "2670000"
+ */
+export function roundUpUSDCBaseAmountToNearest(value: string): string {
+  const divisor = new Big(10).pow(4); // Round to nearest 10,000
+  const srcAmountBig = new Big(value);
+  const remainder = srcAmountBig.mod(divisor);
+  // If remainder is already 0 (exactly divisible by 10^4), return the original amount
+  if (remainder.eq(0)) {
+    return value;
+  }
+  const res = srcAmountBig.plus(divisor.minus(remainder)).toString();
+  return res;
+}

package/src/anyspend/utils/orderPayload.ts

@@ -0,0 +1,63 @@
+import { Nft, OrderType, Token, Tournament } from "@b3dotfun/sdk/anyspend/types";
+import { normalizeAddress } from "@b3dotfun/sdk/anyspend/utils";
+
+export type OrderParams = {
+  orderType: OrderType;
+  srcToken: Token;
+  dstToken: Token;
+  expectedDstAmount?: string;
+  nft?: Nft & { price: string };
+  tournament?: Tournament & { contractAddress: string; entryPriceOrFundAmount: string };
+  payload?: any;
+};
+
+export const buildPayload = (orderType: OrderType, params: OrderParams) => {
+  const { nft, tournament, payload, expectedDstAmount } = params;
+  switch (orderType) {
+    case OrderType.Swap:
+      return {
+        expectedDstAmount,
+        actualDstAmount: null
+      };
+    case OrderType.MintNFT:
+      return {
+        contractAddress: nft ? normalizeAddress(nft.contractAddress) : "",
+        nftPrice: nft?.price || ""
+      };
+    case OrderType.JoinTournament:
+      return {
+        contractAddress: tournament?.contractAddress,
+        entryPrice: tournament?.entryPriceOrFundAmount
+      };
+    case OrderType.FundTournament:
+      return {
+        contractAddress: tournament?.contractAddress,
+        fundAmount: tournament?.entryPriceOrFundAmount
+      };
+    case OrderType.Custom:
+      return { ...payload };
+    default:
+      throw new Error(`Invalid order type: ${orderType}`);
+  }
+};
+
+export const buildMetadata = (orderType: OrderType, params: OrderParams) => {
+  const { srcToken, dstToken, nft, tournament, payload } = params;
+  const baseMetadata = {
+    srcToken,
+    dstToken
+  };
+  switch (orderType) {
+    case OrderType.Swap:
+      return { ...baseMetadata };
+    case OrderType.MintNFT:
+      return { ...baseMetadata, nft };
+    case OrderType.JoinTournament:
+    case OrderType.FundTournament:
+      return { ...baseMetadata, tournament };
+    case OrderType.Custom:
+      return { ...baseMetadata, action: payload.action };
+    default:
+      throw new Error(`Invalid order type: ${orderType}`);
+  }
+};

package/src/anyspend/utils/string.ts

@@ -0,0 +1,4 @@
+export const capitalizeFirstLetter = (stringToCapitalize: string): string => {
+  if (!stringToCapitalize) return "";
+  return stringToCapitalize.charAt(0).toUpperCase() + stringToCapitalize.slice(1);
+};

package/src/anyspend/utils/token.ts

@@ -0,0 +1,72 @@
+import { Token } from "@b3dotfun/sdk/anyspend/types";
+import { avalanche, bsc, polygon } from "viem/chains";
+import { RELAY_ETH_ADDRESS, RELAY_SOL_ADDRESS, RELAY_SOLANA_MAINNET_CHAIN_ID } from "@b3dotfun/sdk/anyspend/constants";
+
+export function isNativeToken(address: string): boolean {
+  return address.toLowerCase() === RELAY_ETH_ADDRESS || address.toLowerCase() === RELAY_SOL_ADDRESS;
+}
+
+export function getSolanaToken(): Token {
+  return {
+    chainId: RELAY_SOLANA_MAINNET_CHAIN_ID,
+    address: RELAY_SOL_ADDRESS,
+    symbol: "SOL",
+    name: "Solana",
+    decimals: 9,
+    metadata: {
+      logoURI: "https://assets.relay.link/icons/square/792703809/light.png"
+    }
+  };
+}
+
+export function getEthToken(chainId: number): Token {
+  return {
+    chainId: chainId,
+    address: RELAY_ETH_ADDRESS,
+    symbol: "ETH",
+    name: "Ethereum",
+    decimals: 18,
+    metadata: {
+      logoURI: "https://assets.relay.link/icons/square/1/light.png"
+    }
+  };
+}
+
+export function getPolToken(): Token {
+  return {
+    chainId: polygon.id,
+    address: RELAY_ETH_ADDRESS,
+    symbol: "POL",
+    name: "Polygon",
+    decimals: 18,
+    metadata: {
+      logoURI: "https://s2.coinmarketcap.com/static/img/coins/64x64/28321.png"
+    }
+  };
+}
+
+export function getBnbToken(): Token {
+  return {
+    chainId: bsc.id,
+    address: RELAY_ETH_ADDRESS,
+    symbol: "BNB",
+    name: "BNB",
+    decimals: 18,
+    metadata: {
+      logoURI: "https://s2.coinmarketcap.com/static/img/coins/64x64/1839.png"
+    }
+  };
+}
+
+export function getAvaxToken(): Token {
+  return {
+    chainId: avalanche.id,
+    address: RELAY_ETH_ADDRESS,
+    symbol: "AVAX",
+    name: "AVAX",
+    decimals: 18,
+    metadata: {
+      logoURI: "https://s2.coinmarketcap.com/static/img/coins/64x64/5805.png"
+    }
+  };
+}