@b3dotfun/anyspend-sdk/dist/index.js

React Hooks and UI Components for AnySpend by B3

// src/types/chain.ts
var ChainType = /* @__PURE__ */ ((ChainType2) => {
  ChainType2["EVM"] = "evm";
  ChainType2["SOLANA"] = "solana";
  return ChainType2;
})(ChainType || {});

// src/types/globalWallet.ts
import { z } from "zod";
var zGlobalWallet = z.object({
  chain: z.number(),
  encryptedPrvkey: z.string(),
  address: z.string(),
  orderId: z.string().nullable()
});

// src/types/nft.ts
import { z as z3 } from "zod";

// src/types/token.ts
import { z as z2 } from "zod";
var zToken = z2.object({
  chainId: z2.number(),
  address: z2.string(),
  symbol: z2.string(),
  name: z2.string(),
  decimals: z2.number(),
  metadata: z2.object({
    logoURI: z2.string().optional()
  })
});

// src/types/nft.ts
var NftType = /* @__PURE__ */ ((NftType2) => {
  NftType2["ERC721"] = "erc721";
  NftType2["ERC1155"] = "erc1155";
  return NftType2;
})(NftType || {});
var zBaseNft = z3.object({
  type: z3.nativeEnum(NftType),
  contractAddress: z3.string(),
  name: z3.string(),
  description: z3.string(),
  imageUrl: z3.string()
});
var zNft = z3.discriminatedUnion("type", [
  zBaseNft.extend({
    type: z3.literal("erc721" /* ERC721 */)
  }),
  zBaseNft.extend({
    type: z3.literal("erc1155" /* ERC1155 */),
    tokenId: z3.number(),
    imageUrl: z3.string()
  })
]);
var zMintNftPayload = z3.object({
  contractAddress: z3.string(),
  nftPrice: z3.string()
});
var zMintNftMetadata = z3.object({
  srcToken: zToken,
  dstToken: zToken,
  nft: zNft
});

// src/types/onramp.ts
import { z as z4 } from "zod";
var OnrampVendor = /* @__PURE__ */ ((OnrampVendor2) => {
  OnrampVendor2["Coinbase"] = "coinbase";
  OnrampVendor2["Stripe"] = "stripe";
  OnrampVendor2["StripeWeb2"] = "stripe-web2";
  return OnrampVendor2;
})(OnrampVendor || {});
var zOnrampMetadata = z4.object({
  country: z4.string(),
  vendor: z4.nativeEnum(OnrampVendor),
  paymentMethod: z4.string(),
  ipAddress: z4.string().ip("Invalid IP address").optional(),
  redirectUrl: z4.string()
});

// src/types/order.ts
import { z as z9 } from "zod";

// src/types/permit.ts
import { z as z5 } from "zod";
var zPermit = z5.object({
  ownerAddress: z5.string(),
  deadline: z5.number(),
  v: z5.number(),
  r: z5.string(),
  s: z5.string()
});

// src/types/swap.ts
import { z as z6 } from "zod";
var zSwapPayload = z6.object({
  expectedDstAmount: z6.string(),
  actualDstAmount: z6.string().nullable()
});
var zSwapMetadata = z6.object({
  srcToken: zToken,
  dstToken: zToken
});

// src/types/tournament.ts
import { z as z7 } from "zod";
var zTournament = z7.object({
  slug: z7.string(),
  name: z7.string(),
  description: z7.string(),
  imageUrl: z7.string()
});
var zJoinTournamentPayload = z7.object({
  contractAddress: z7.string(),
  entryPrice: z7.string()
});
var zFundTournamentPayload = z7.object({
  contractAddress: z7.string(),
  fundAmount: z7.string()
});
var zTournamentMetadata = z7.object({
  srcToken: zToken,
  dstToken: zToken,
  tournament: zTournament
});

// src/types/custom.ts
import z8 from "zod";
var zCustomPayload = z8.object({
  data: z8.string(),
  to: z8.string(),
  amount: z8.string()
});
var zCustomMetadata = z8.object({
  srcToken: zToken,
  dstToken: zToken,
  action: z8.string().optional()
});

// src/types/order.ts
var OrderStatus = /* @__PURE__ */ ((OrderStatus2) => {
  OrderStatus2["ScanningDepositTransaction"] = "scanning_deposit_transaction";
  OrderStatus2["WaitingStripePayment"] = "waiting_stripe_payment";
  OrderStatus2["ObtainToken"] = "obtain_token";
  OrderStatus2["ObtainFailed"] = "obtain_failed";
  OrderStatus2["Expired"] = "expired";
  OrderStatus2["SendingTokenFromVault"] = "sending_token_from_vault";
  OrderStatus2["Relay"] = "relay";
  OrderStatus2["Executed"] = "executed";
  OrderStatus2["Refunding"] = "refunding";
  OrderStatus2["Refunded"] = "refunded";
  OrderStatus2["Failure"] = "failure";
  return OrderStatus2;
})(OrderStatus || {});
var OrderType = /* @__PURE__ */ ((OrderType2) => {
  OrderType2["Swap"] = "swap";
  OrderType2["MintNFT"] = "mint_nft";
  OrderType2["JoinTournament"] = "join_tournament";
  OrderType2["FundTournament"] = "fund_tournament";
  OrderType2["Custom"] = "custom";
  return OrderType2;
})(OrderType || {});
var zBaseOrder = z9.object({
  id: z9.string(),
  recipientAddress: z9.string(),
  globalAddress: z9.string(),
  srcChain: z9.number(),
  dstChain: z9.number(),
  srcTokenAddress: z9.string(),
  dstTokenAddress: z9.string(),
  srcAmount: z9.string(),
  status: z9.nativeEnum(OrderStatus),
  errorDetails: z9.string().nullable(),
  createdAt: z9.number(),
  expiredAt: z9.number(),
  onrampMetadata: zOnrampMetadata.nullable(),
  creatorAddress: z9.string().nullable(),
  oneClickBuyUrl: z9.string().nullable(),
  stripePaymentIntentId: z9.string().nullable(),
  permit: zPermit.nullable()
});
var zOrder = z9.discriminatedUnion("type", [
  zBaseOrder.extend({
    type: z9.literal("swap" /* Swap */),
    payload: zSwapPayload,
    metadata: zSwapMetadata
  }),
  zBaseOrder.extend({
    type: z9.literal("mint_nft" /* MintNFT */),
    payload: zMintNftPayload,
    metadata: zMintNftMetadata
  }),
  zBaseOrder.extend({
    type: z9.literal("join_tournament" /* JoinTournament */),
    payload: zJoinTournamentPayload,
    metadata: zTournamentMetadata
  }),
  zBaseOrder.extend({
    type: z9.literal("fund_tournament" /* FundTournament */),
    payload: zFundTournamentPayload,
    metadata: zTournamentMetadata
  }),
  zBaseOrder.extend({
    type: z9.literal("custom" /* Custom */),
    payload: zCustomPayload,
    metadata: zCustomMetadata
  })
]);

// src/types/relay.ts
import { z as z10 } from "zod";
var zRelayStatus = z10.enum(["refund", "delayed", "waiting", "failure", "pending", "success"]);
var zRelayStepStatus = z10.enum(["complete", "incomplete"]);
var TradeType = /* @__PURE__ */ ((TradeType2) => {
  TradeType2["EXACT_INPUT"] = "EXACT_INPUT";
  TradeType2["EXPECTED_OUTPUT"] = "EXPECTED_OUTPUT";
  TradeType2["EXACT_OUTPUT"] = "EXACT_OUTPUT";
  return TradeType2;
})(TradeType || {});

// src/types/transaction.ts
import { z as z11 } from "zod";
var zDepositTransaction = z11.object({
  orderId: z11.string(),
  chain: z11.number(),
  from: z11.string().nullable(),
  txHash: z11.string(),
  amount: z11.string(),
  createdAt: z11.number()
});
var zRelayTransaction = z11.object({
  orderId: z11.string(),
  chain: z11.number(),
  txHash: z11.string(),
  status: zRelayStatus,
  createdAt: z11.number()
});
var zExecuteTransaction = z11.object({
  orderId: z11.string(),
  chain: z11.number(),
  txHash: z11.string(),
  createdAt: z11.number()
});
var zRefundTransaction = z11.object({
  orderId: z11.string(),
  chain: z11.number(),
  txHash: z11.string(),
  amount: z11.string(),
  status: z11.enum(["success", "failure"]),
  createdAt: z11.number()
});

// src/types/req-res/createOrder.ts
import { z as z12 } from "zod";
var zBaseCreateOrderBody = z12.object({
  recipientAddress: z12.string(),
  srcChain: z12.number(),
  dstChain: z12.number(),
  srcTokenAddress: z12.string(),
  dstTokenAddress: z12.string(),
  srcAmount: z12.string(),
  onramp: zOnrampMetadata.optional(),
  creatorAddress: z12.string().optional()
});
var zCreateSwapOrderBody = zBaseCreateOrderBody.extend({
  type: z12.literal("swap" /* Swap */),
  payload: zSwapPayload,
  metadata: zSwapMetadata
});
var zCreateMintNftOrderBody = zBaseCreateOrderBody.extend({
  type: z12.literal("mint_nft" /* MintNFT */),
  payload: zMintNftPayload,
  metadata: zMintNftMetadata
});
var zCreateJoinTournamentOrderBody = zBaseCreateOrderBody.extend({
  type: z12.literal("join_tournament" /* JoinTournament */),
  payload: zJoinTournamentPayload,
  metadata: zTournamentMetadata
});
var zCreateFundTournamentOrderBody = zBaseCreateOrderBody.extend({
  type: z12.literal("fund_tournament" /* FundTournament */),
  payload: zFundTournamentPayload,
  metadata: zTournamentMetadata
});
var zCreateCustomOrderBody = zBaseCreateOrderBody.extend({
  type: z12.literal("custom" /* Custom */),
  payload: zCustomPayload,
  metadata: zCustomMetadata
});
var zCreateOrderRequest = z12.object({
  body: z12.discriminatedUnion("type", [
    zCreateSwapOrderBody,
    zCreateMintNftOrderBody,
    zCreateJoinTournamentOrderBody,
    zCreateFundTournamentOrderBody,
    zCreateCustomOrderBody
  ])
});
var zCreateOrderResponse = z12.object({
  success: z12.boolean(),
  message: z12.string(),
  data: zOrder,
  statusCode: z12.number()
});

// src/types/req-res/getCoinbaseOnrampOptions.ts
import { z as z13 } from "zod";
var zNetwork = z13.object({
  name: z13.string(),
  displayName: z13.string(),
  contractAddress: z13.string(),
  chainId: z13.string()
});
var zPaymentLimit = z13.object({
  id: z13.string(),
  min: z13.string(),
  max: z13.string()
});
var zPaymentCurrency = z13.object({
  id: z13.string(),
  limits: z13.array(zPaymentLimit)
});
var zPurchaseCurrency = z13.object({
  id: z13.string(),
  name: z13.string(),
  symbol: z13.string(),
  networks: z13.array(zNetwork),
  iconUrl: z13.string()
});
var zGetCoinbaseOnrampOptionsResponse = z13.object({
  paymentCurrencies: z13.array(zPaymentCurrency),
  purchaseCurrencies: z13.array(zPurchaseCurrency)
});

// src/types/req-res/getOrderAndTransactions.ts
import { z as z14 } from "zod";
var zGetOrderAndTransactionsRequest = z14.object({
  params: z14.object({
    orderId: z14.string()
  })
});
var zGetOrderAndTxsResponse = z14.object({
  success: z14.boolean(),
  message: z14.string(),
  data: z14.object({
    order: zOrder,
    depositTxs: z14.array(zDepositTransaction).nullable(),
    relayTx: zRelayTransaction.nullable(),
    executeTx: zExecuteTransaction.nullable(),
    refundTxs: z14.array(zRefundTransaction).nullable()
  }),
  statusCode: z14.number()
});

// src/types/req-res/getOrderByCreator.ts
import { z as z15 } from "zod";
var zGetOrdersByCreatorRequest = z15.object({
  query: z15.object({
    creatorAddress: z15.string().optional(),
    limit: z15.string().optional(),
    offset: z15.string().optional()
  })
});

// src/types/req-res/getOrderHistory.ts
import { z as z16 } from "zod";
var zGetOrderHistoryResponse = z16.object({
  success: z16.boolean(),
  message: z16.string(),
  data: z16.array(zOrder),
  statusCode: z16.number()
});

// src/types/req-res/getQuote.ts
import { z as z17 } from "zod";
var zGetQuoteBody = z17.object({
  srcChain: z17.number(),
  dstChain: z17.number(),
  srcTokenAddress: z17.string(),
  dstTokenAddress: z17.string()
});
var zGetQuoteForSwapOrderBody = zGetQuoteBody.extend({
  type: z17.literal("swap" /* Swap */),
  tradeType: z17.nativeEnum(TradeType),
  amount: z17.string()
});
var zGetQuoteForMintNftOrderBody = zGetQuoteBody.extend({
  type: z17.literal("mint_nft" /* MintNFT */),
  contractAddress: z17.string(),
  price: z17.string()
});
var zGetQuoteForJoinTournamentOrderBody = zGetQuoteBody.extend({
  type: z17.literal("join_tournament" /* JoinTournament */),
  contractAddress: z17.string(),
  price: z17.string()
});
var zGetQuoteForFundTournamentOrderBody = zGetQuoteBody.extend({
  type: z17.literal("fund_tournament" /* FundTournament */),
  contractAddress: z17.string(),
  fundAmount: z17.string()
});
var zGetQuoteForCustomOrderBody = zGetQuoteBody.extend({
  type: z17.literal("custom" /* Custom */),
  payload: zCustomPayload
});
var zGetQuoteRequest = z17.object({
  body: z17.discriminatedUnion("type", [
    zGetQuoteForSwapOrderBody,
    zGetQuoteForMintNftOrderBody,
    zGetQuoteForJoinTournamentOrderBody,
    zGetQuoteForFundTournamentOrderBody,
    zGetQuoteForCustomOrderBody
  ])
});

// src/types/req-res/getTokenList.ts
import { z as z18 } from "zod";
var zGetTokenListResponse = z18.object({
  success: z18.boolean(),
  message: z18.string(),
  data: z18.array(
    z18.object({
      chainId: z18.number(),
      address: z18.string(),
      symbol: z18.string(),
      name: z18.string(),
      decimals: z18.number(),
      metadata: z18.object({
        logoURI: z18.string().optional()
      })
    })
  )
});

// src/types/req-res/sendPermitData.ts
import { z as z19 } from "zod";
var zSendPermitDataRequest = z19.object({
  body: z19.object({
    orderId: z19.string(),
    permitData: zPermit
  })
});

// src/utils/chain.ts
import invariant from "invariant";
import {
  createPublicClient,
  createWalletClient,
  defineChain,
  http,
  parseEther
} from "viem";
import {
  arbitrum,
  avalanche as avalanche2,
  b3,
  b3Sepolia,
  base as base2,
  baseSepolia,
  bsc as bsc2,
  mainnet,
  optimism,
  polygon as polygon2,
  sepolia
} from "viem/chains";

// src/constants.ts
import { base } from "viem/chains";
var ANYSPEND_MAINNET_BASE_URL = process.env.NEXT_PUBLIC_ANYSPEND_BASE_URL || "https://anyspend-mainnet.up.railway.app";
var ANYSPEND_TESTNET_BASE_URL = process.env.NEXT_PUBLIC_ANYSPEND_BASE_URL || "https://anyspend-testnet.up.railway.app";
var RELAY_ETH_ADDRESS = "0x0000000000000000000000000000000000000000";
var RELAY_SOL_ADDRESS = "11111111111111111111111111111111";
var RELAY_SOLANA_MAINNET_CHAIN_ID = 792703809;
var SOLANA_ASSOCIATED_TOKEN_ACCOUNT_PROGRAM_ID = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
var SOLANA_TOKEN_2022_PROGRAM_ID = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
var B3_TOKEN = {
  chainId: 8453,
  address: "0xb3b32f9f8827d4634fe7d973fa1034ec9fddb3b3",
  decimals: 18,
  name: "B3",
  symbol: "B3",
  metadata: {
    logoURI: "https://s2.coinmarketcap.com/static/img/coins/64x64/35690.png"
  }
};
var USDC_BASE = {
  symbol: "USDC",
  chainId: base.id,
  address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
  name: "USD Coin",
  decimals: 6,
  metadata: {
    logoURI: "https://polygonscan.com/token/images/usdc_32.png"
  }
};

// src/utils/token.ts
import { avalanche, bsc, polygon } from "viem/chains";
function isNativeToken(address) {
  return address.toLowerCase() === RELAY_ETH_ADDRESS || address.toLowerCase() === RELAY_SOL_ADDRESS;
}
function getSolanaToken() {
  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"
    }
  };
}
function getEthToken(chainId) {
  return {
    chainId,
    address: RELAY_ETH_ADDRESS,
    symbol: "ETH",
    name: "Ethereum",
    decimals: 18,
    metadata: {
      logoURI: "https://assets.relay.link/icons/square/1/light.png"
    }
  };
}
function getPolToken() {
  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"
    }
  };
}
function getBnbToken() {
  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"
    }
  };
}
function getAvaxToken() {
  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"
    }
  };
}

// src/utils/chain.ts
function getCustomEvmChain(chain, rpcUrl) {
  return defineChain({ ...chain, rpcUrls: { default: { http: [rpcUrl] } } });
}
var EVM_MAINNET = {
  [mainnet.id]: {
    id: mainnet.id,
    name: mainnet.name,
    type: "evm" /* 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: 4e3,
    // 4 seconds for Ethereum mainnet
    zapperEnum: "ETHEREUM_MAINNET",
    coingeckoName: "eth"
  },
  [arbitrum.id]: {
    id: arbitrum.id,
    name: "Arbitrum",
    type: "evm" /* 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"
  },
  [base2.id]: {
    id: base2.id,
    name: base2.name,
    logoUrl: "https://assets.relay.link/icons/square/8453/light.png",
    type: "evm" /* EVM */,
    nativeRequired: parseEther("0.0001"),
    canDepositNative: true,
    defaultToken: getEthToken(base2.id),
    nativeToken: getEthToken(base2.id),
    viem: getCustomEvmChain(
      base2,
      "https://sly-indulgent-bird.base-mainnet.quiknode.pro/4e31fab6845eb29a2764723a43896999fe962e48/"
    ),
    pollingInterval: 1e3,
    // 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: "evm" /* 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: 1e3,
    // 1 second for Optimism
    zapperEnum: "OPTIMISM_MAINNET",
    coingeckoName: "optimism"
  },
  [polygon2.id]: {
    id: polygon2.id,
    name: polygon2.name,
    logoUrl: "https://assets.relay.link/icons/square/137/light.png",
    type: "evm" /* EVM */,
    nativeRequired: parseEther("0.1"),
    canDepositNative: true,
    defaultToken: getPolToken(),
    nativeToken: getPolToken(),
    viem: getCustomEvmChain(
      polygon2,
      "https://purple-young-field.matic.quiknode.pro/ca54f365c1a4c7f970223eb8087e0fc579feba12/"
    ),
    pollingInterval: 1e3,
    // 1 second for Polygon
    zapperEnum: "POLYGON_MAINNET",
    coingeckoName: "polygon"
  },
  [avalanche2.id]: {
    id: avalanche2.id,
    name: avalanche2.name,
    logoUrl: "https://assets.relay.link/icons/square/43114/light.png",
    type: "evm" /* EVM */,
    nativeRequired: parseEther("0.005"),
    canDepositNative: true,
    defaultToken: getAvaxToken(),
    nativeToken: getAvaxToken(),
    viem: getCustomEvmChain(
      avalanche2,
      "https://burned-billowing-pond.avalanche-mainnet.quiknode.pro/24289978a524a18ef42e568e04fe8cad8c7b6720/ext/bc/C/rpc/"
    ),
    pollingInterval: 1e3,
    // 1 second for Avalanche
    zapperEnum: "AVALANCHE_MAINNET",
    coingeckoName: "avalanche"
  },
  [bsc2.id]: {
    id: bsc2.id,
    name: bsc2.name,
    logoUrl: "https://avatars.githubusercontent.com/u/45615063?s=280&v=4",
    type: "evm" /* EVM */,
    nativeRequired: parseEther("0.00001"),
    canDepositNative: false,
    defaultToken: getBnbToken(),
    nativeToken: getBnbToken(),
    viem: getCustomEvmChain(bsc2, "https://bsc-rpc.publicnode.com"),
    pollingInterval: 1e3,
    // 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: "evm" /* 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: 1e3,
    // 1 second for B3
    zapperEnum: "B3_MAINNET",
    coingeckoName: "b3"
  }
};
var EVM_TESTNET = {
  [sepolia.id]: {
    id: sepolia.id,
    name: sepolia.name,
    logoUrl: "https://assets.relay.link/icons/square/1/light.png",
    type: "evm" /* EVM */,
    nativeRequired: parseEther("0.00001"),
    canDepositNative: true,
    defaultToken: getEthToken(sepolia.id),
    nativeToken: getEthToken(sepolia.id),
    viem: sepolia,
    pollingInterval: 1e3
    // 1 second for Sepolia
  },
  [baseSepolia.id]: {
    id: baseSepolia.id,
    name: baseSepolia.name,
    logoUrl: "https://assets.relay.link/icons/square/8453/light.png",
    type: "evm" /* EVM */,
    nativeRequired: parseEther("0.00001"),
    canDepositNative: true,
    defaultToken: getEthToken(baseSepolia.id),
    nativeToken: getEthToken(baseSepolia.id),
    viem: baseSepolia,
    pollingInterval: 1e3
    // 1 second for Base Sepolia
  },
  [b3Sepolia.id]: {
    id: b3Sepolia.id,
    name: b3Sepolia.name,
    logoUrl: "https://assets.relay.link/icons/square/8333/light.png",
    type: "evm" /* EVM */,
    nativeRequired: parseEther("0.00001"),
    canDepositNative: true,
    defaultToken: getEthToken(b3Sepolia.id),
    nativeToken: getEthToken(b3Sepolia.id),
    viem: b3Sepolia,
    pollingInterval: 1e3
    // 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,
  // },
};
var SOLANA_MAINNET = {
  id: RELAY_SOLANA_MAINNET_CHAIN_ID,
  name: "Solana",
  logoUrl: "https://assets.relay.link/icons/square/792703809/light.png",
  type: "solana" /* SOLANA */,
  nativeRequired: BigInt(1e7),
  // 0.01 SOL
  canDepositNative: true,
  defaultToken: getSolanaToken(),
  nativeToken: getSolanaToken()
};
var EVM_CHAINS = { ...EVM_MAINNET, ...EVM_TESTNET };
var SOLANA_CHAINS = { [RELAY_SOLANA_MAINNET_CHAIN_ID]: SOLANA_MAINNET };
var ALL_CHAINS = { ...EVM_CHAINS, ...SOLANA_CHAINS };
function getSolanaChains(network) {
  invariant(network === "mainnet", "Solana chain is only supported on mainnet");
  return SOLANA_MAINNET;
}
function getAllEvmChains(network) {
  return network === "mainnet" ? EVM_MAINNET : EVM_TESTNET;
}
function getChainType(chainId) {
  invariant(ALL_CHAINS[chainId], `Chain ${chainId} is not supported`);
  return ALL_CHAINS[chainId].type;
}
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
  });
}
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
  });
}
function getNativeRequired(chainId) {
  invariant(ALL_CHAINS[chainId], `Chain ${chainId} is not supported`);
  return ALL_CHAINS[chainId].nativeRequired;
}
function canDepositNative(chainId) {
  invariant(ALL_CHAINS[chainId], `Chain ${chainId} is not supported`);
  return ALL_CHAINS[chainId].canDepositNative;
}
function isMainnet(chainId) {
  return EVM_MAINNET[chainId] !== void 0 || RELAY_SOLANA_MAINNET_CHAIN_ID === chainId;
}
function isTestnet(chainId) {
  return EVM_TESTNET[chainId] !== void 0;
}
function getDefaultToken(chainId) {
  invariant(ALL_CHAINS[chainId], `Chain ${chainId} is not supported`);
  return ALL_CHAINS[chainId].defaultToken;
}
function getChainName(chainId) {
  invariant(ALL_CHAINS[chainId], `Chain ${chainId} is not supported`);
  return EVM_CHAINS[chainId] ? EVM_CHAINS[chainId].viem.name : "Solana";
}
function getPaymentUrl(address, amount, currency) {
  if (currency === "ETH") {
    return `ethereum:${address}?value=${amount.toString()}`;
  }
  return `ethereum:${address}`;
}
function getExplorerTxUrl(chainId, txHash) {
  if (EVM_CHAINS[chainId]) {
    return EVM_CHAINS[chainId].viem.blockExplorers?.default.url + "/tx/" + txHash;
  }
  return "https://solscan.io/tx/" + txHash;
}
function getExplorerAddressUrl(chainId, address) {
  if (EVM_CHAINS[chainId]) {
    return EVM_CHAINS[chainId].viem.blockExplorers?.default.url + "/address/" + address;
  }
  return "https://solscan.io/account/" + address;
}
function getMulticall3Address(chainId) {
  const chainType = getChainType(chainId);
  invariant(chainType === "evm" /* EVM */, "chainType must be EVM");
  const multicall3 = EVM_CHAINS[chainId].viem.contracts?.multicall3;
  invariant(multicall3, `multicall3 of chain ${chainId} undefined`);
  return multicall3.address;
}
function getNativeToken(chainId) {
  invariant(ALL_CHAINS[chainId], `Chain ${chainId} undefined`);
  return ALL_CHAINS[chainId].nativeToken;
}
function isEvmChain(chainId) {
  return Boolean(EVM_CHAINS[chainId]);
}

// src/services/anyspend.ts
import invariant2 from "invariant";
var anyspendService = {
  getTokenList: async (isMainnet2, chainId, query) => {
    const response = await fetch(
      `${isMainnet2 ? ANYSPEND_MAINNET_BASE_URL : ANYSPEND_TESTNET_BASE_URL}/chains/${chainId}/tokens?limit=100&term=${query}`
    );
    const data = await response.json();
    invariant2(response.status === 200, `Failed to fetch token list for chain ${chainId}`);
    const parsedData = zGetTokenListResponse.parse(data);
    return parsedData.data;
  },
  getToken: async (isMainnet2, chainId, tokenAddress) => {
    if (isNativeToken(tokenAddress)) {
      return getNativeToken(chainId);
    }
    const tokenList = await anyspendService.getTokenList(isMainnet2, chainId, tokenAddress);
    const token = tokenList.find((t) => t.address.toLowerCase() === tokenAddress.toLowerCase());
    if (!token) {
      throw new Error(`Token ${tokenAddress} not found on chain ${chainId}`);
    }
    return token;
  },
  getQuote: async (isMainnet2, req) => {
    const url = `${isMainnet2 ? ANYSPEND_MAINNET_BASE_URL : ANYSPEND_TESTNET_BASE_URL}/orders/quote`;
    const response = await fetch(url, {
      method: "POST",
      headers: {
        "Content-Type": "application/json"
      },
      body: JSON.stringify(req)
    });
    const data = await response.json();
    if (response.status !== 200) throw new Error(data.message);
    return data;
  },
  // Order related
  createOrder: async ({
    isMainnet: isMainnet2,
    recipientAddress,
    type,
    srcChain,
    dstChain,
    srcTokenAddress,
    dstTokenAddress,
    srcAmount,
    payload,
    onramp,
    metadata,
    creatorAddress
  }) => {
    const response = await fetch(`${isMainnet2 ? ANYSPEND_MAINNET_BASE_URL : ANYSPEND_TESTNET_BASE_URL}/orders`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json"
      },
      body: JSON.stringify({
        recipientAddress,
        type,
        srcChain,
        dstChain,
        srcTokenAddress,
        dstTokenAddress,
        srcAmount,
        payload,
        onramp,
        metadata,
        creatorAddress
      })
    });
    const data = await response.json();
    invariant2(data.statusCode === 200, data.message);
    return data;
  },
  getOrderAndTransactions: async (isMainnet2, orderId) => {
    const response = await fetch(
      `${isMainnet2 ? ANYSPEND_MAINNET_BASE_URL : ANYSPEND_TESTNET_BASE_URL}/orders/${orderId}`
    );
    const responseData = await response.json();
    const data = zGetOrderAndTxsResponse.parse(responseData);
    return data;
  },
  getOrderHistory: async (isMainnet2, creatorAddress, limit = 100, offset = 0) => {
    const params = new URLSearchParams({
      limit: limit.toString(),
      offset: offset.toString()
    });
    if (creatorAddress) {
      params.append("creatorAddress", creatorAddress);
    }
    const response = await fetch(
      `${isMainnet2 ? ANYSPEND_MAINNET_BASE_URL : ANYSPEND_TESTNET_BASE_URL}/orders?${params.toString()}`
    );
    const responseData = await response.json();
    const data = zGetOrderHistoryResponse.parse(responseData);
    return data;
  },
  getCoinbaseOnrampOptions: async (isMainnet2, country) => {
    const params = new URLSearchParams({
      country
    });
    const response = await fetch(
      `${isMainnet2 ? ANYSPEND_MAINNET_BASE_URL : ANYSPEND_TESTNET_BASE_URL}/onramp/coinbase/options?${params.toString()}`
    );
    const data = await response.json();
    const parsedData = zGetCoinbaseOnrampOptionsResponse.parse(data.data);
    return parsedData;
  },
  checkStripeSupport: async (isMainnet2, ipAddress, usdAmount) => {
    const params = new URLSearchParams({
      ipAddress,
      usdAmount: usdAmount || ""
    });
    const response = await fetch(
      `${isMainnet2 ? ANYSPEND_MAINNET_BASE_URL : ANYSPEND_TESTNET_BASE_URL}/onramp/stripe/supported?${params.toString()}`
    );
    const data = await response.json();
    invariant2(response.status === 200, "Failed to check Stripe support");
    return data.data;
  },
  sendPermitData: async ({ isMainnet: isMainnet2, orderId, permitData }) => {
    const response = await fetch(
      `${isMainnet2 ? ANYSPEND_MAINNET_BASE_URL : ANYSPEND_TESTNET_BASE_URL}/orders/send-permit`,
      {
        method: "POST",
        headers: {
          "Content-Type": "application/json"
        },
        body: JSON.stringify({
          orderId,
          permitData
        })
      }
    );
    return response.json();
  },
  getStripeClientSecret: async (isMainnet2, paymentIntentId) => {
    const response = await fetch(
      `${isMainnet2 ? ANYSPEND_MAINNET_BASE_URL : ANYSPEND_TESTNET_BASE_URL}/stripe/clientSecret?paymentIntentId=${paymentIntentId}`
    );
    const data = await response.json();
    return data.data;
  }
};

// src/utils/address.ts
import { isAddress } from "viem";
function isSolanaAddress(address) {
  const solanaAddressRegex = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
  return solanaAddressRegex.test(address);
}
function isEvmOrSolanaAddress(address) {
  return isAddress(address) || isSolanaAddress(address);
}
function normalizeAddress(address) {
  if (isSolanaAddress(address)) {
    return address;
  }
  return address.toLowerCase();
}
function eqci(a, b) {
  if (a === "" && b === "") return true;
  if (!a || !b) return false;
  return a.toLowerCase() === b.toLowerCase();
}

// src/hooks/useAnyspendCreateOnrampOrder.ts
import { useMutation } from "@tanstack/react-query";
import { useMemo } from "react";
import { parseUnits } from "viem";
import { base as base3 } from "viem/chains";

// src/utils/orderPayload.ts
var buildPayload = (orderType, params) => {
  const { nft, tournament, payload, expectedDstAmount } = params;
  switch (orderType) {
    case "swap" /* Swap */:
      return {
        expectedDstAmount,
        actualDstAmount: null
      };
    case "mint_nft" /* MintNFT */:
      return {
        contractAddress: nft ? normalizeAddress(nft.contractAddress) : "",
        nftPrice: nft?.price || ""
      };
    case "join_tournament" /* JoinTournament */:
      return {
        contractAddress: tournament?.contractAddress,
        entryPrice: tournament?.entryPriceOrFundAmount
      };
    case "fund_tournament" /* FundTournament */:
      return {
        contractAddress: tournament?.contractAddress,
        fundAmount: tournament?.entryPriceOrFundAmount
      };
    case "custom" /* Custom */:
      return { ...payload };
    default:
      throw new Error(`Invalid order type: ${orderType}`);
  }
};
var buildMetadata = (orderType, params) => {
  const { srcToken, dstToken, nft, tournament, payload } = params;
  const baseMetadata = {
    srcToken,
    dstToken
  };
  switch (orderType) {
    case "swap" /* Swap */:
      return { ...baseMetadata };
    case "mint_nft" /* MintNFT */:
      return { ...baseMetadata, nft };
    case "join_tournament" /* JoinTournament */:
    case "fund_tournament" /* FundTournament */:
      return { ...baseMetadata, tournament };
    case "custom" /* Custom */:
      return { ...baseMetadata, action: payload.action };
    default:
      throw new Error(`Invalid order type: ${orderType}`);
  }
};

// src/hooks/useAnyspendCreateOnrampOrder.ts
function useAnyspendCreateOnrampOrder({ onSuccess, onError } = {}) {
  const { mutate: createOrder, isPending } = useMutation({
    mutationFn: async (params) => {
      const {
        isMainnet: isMainnet2,
        recipientAddress,
        orderType,
        dstChain,
        dstToken,
        srcFiatAmount,
        onramp,
        creatorAddress,
        expectedDstAmount,
        nft,
        tournament,
        payload
      } = params;
      try {
        if (onramp.vendor === "stripe" && !onramp.ipAddress) {
          throw new Error("IP address is required for Stripe onramp");
        }
        if (!onramp.vendor || !onramp.country) {
          throw new Error("Missing required onramp fields: vendor, country");
        }
        const srcToken = USDC_BASE;
        const srcChain = base3.id;
        const srcAmountOnRampInWei = parseUnits(srcFiatAmount, USDC_BASE.decimals);
        return await anyspendService.createOrder({
          isMainnet: isMainnet2,
          recipientAddress: normalizeAddress(recipientAddress),
          type: orderType,
          srcChain,
          srcTokenAddress: normalizeAddress(srcToken.address),
          dstChain,
          dstTokenAddress: normalizeAddress(dstToken.address),
          srcAmount: srcAmountOnRampInWei.toString(),
          payload: buildPayload(orderType, {
            orderType,
            srcToken,
            dstToken,
            expectedDstAmount,
            nft,
            tournament,
            payload
          }),
          onramp,
          metadata: buildMetadata(orderType, {
            orderType,
            srcToken,
            dstToken,
            expectedDstAmount,
            nft,
            tournament,
            payload
          }),
          creatorAddress: creatorAddress ? normalizeAddress(creatorAddress) : void 0
        });
      } catch (error) {
        if (error?.data) {
          throw error.data;
        }
        throw error;
      }
    },
    onSuccess: (data) => {
      onSuccess?.(data);
    },
    onError: (error) => {
      onError?.(error);
    }
  });
  return useMemo(
    () => ({
      createOrder,
      isCreatingOrder: isPending
    }),
    [createOrder, isPending]
  );
}

// src/hooks/useAnyspendCreateOrder.ts
import { useMutation as useMutation2 } from "@tanstack/react-query";
import { useMemo as useMemo2 } from "react";
function useAnyspendCreateOrder({ onSuccess, onError } = {}) {
  const { mutate: createOrder, isPending } = useMutation2({
    mutationFn: async (params) => {
      const {
        isMainnet: isMainnet2,
        recipientAddress,
        orderType,
        srcChain,
        dstChain,
        srcToken,
        dstToken,
        srcAmount,
        creatorAddress
      } = params;
      try {
        return await anyspendService.createOrder({
          isMainnet: isMainnet2,
          recipientAddress: normalizeAddress(recipientAddress),
          type: orderType,
          srcChain,
          dstChain,
          srcTokenAddress: normalizeAddress(srcToken.address),
          dstTokenAddress: normalizeAddress(dstToken.address),
          srcAmount,
          payload: buildPayload(orderType, {
            orderType,
            srcToken,
            dstToken,
            expectedDstAmount: params.expectedDstAmount,
            nft: params.nft,
            tournament: params.tournament,
            payload: params.payload
          }),
          metadata: buildMetadata(orderType, {
            orderType,
            srcToken,
            dstToken,
            expectedDstAmount: params.expectedDstAmount,
            nft: params.nft,
            tournament: params.tournament,
            payload: params.payload
          }),
          creatorAddress: creatorAddress ? normalizeAddress(creatorAddress) : void 0
        });
      } catch (error) {
        if (error?.data) {
          throw error.data;
        }
        throw error;
      }
    },
    onSuccess: (data) => {
      onSuccess?.(data);
    },
    onError: (error) => {
      onError?.(error);
    }
  });
  return useMemo2(
    () => ({
      createOrder,
      isCreatingOrder: isPending
    }),
    [createOrder, isPending]
  );
}

// src/hooks/useAnyspendOrderAndTransactions.ts
import { useQuery } from "@tanstack/react-query";
import isEqual from "lodash/isEqual.js";
import { useCallback, useMemo as useMemo3 } from "react";
function useAnyspendOrderAndTransactions(isMainnet2, orderId) {
  const selectFn = useCallback((data2) => {
    if (!data2) return void 0;
    return data2;
  }, []);
  const { data, isLoading, refetch, error } = useQuery({
    queryKey: ["getAnyspendOrderAndTransactions", orderId],
    queryFn: () => anyspendService.getOrderAndTransactions(isMainnet2, orderId),
    enabled: Boolean(orderId),
    refetchInterval: 3e3,
    staleTime: 1e3,
    select: selectFn,
    structuralSharing: (oldData, newData) => {
      if (isEqual(oldData, newData)) return oldData;
      return newData;
    }
  });
  return useMemo3(
    () => ({
      orderAndTransactions: data,
      isLoadingOrderAndTransactions: isLoading,
      getOrderAndTransactionsError: error,
      refetchOrderAndTransactions: refetch
    }),
    [data, error, isLoading, refetch]
  );
}

// src/hooks/useAnyspendOrderHistory.ts
import { useQuery as useQuery2 } from "@tanstack/react-query";
function useAnyspendOrderHistory(isMainnet2, creatorAddress, limit = 100, offset = 0) {
  const {
    data: rawData = [],
    isLoading,
    refetch,
    error
  } = useQuery2({
    queryKey: ["getOrderHistory", creatorAddress, limit, offset],
    queryFn: async () => {
      const response = await anyspendService.getOrderHistory(isMainnet2, creatorAddress, limit, offset);
      return response.data;
    }
  });
  return {
    orderHistory: rawData,
    isLoadingOrderHistory: isLoading,
    getOrderHistoryError: error,
    refetchOrderHistory: refetch
  };
}

// src/hooks/useAnyspendQuote.ts
import { useQuery as useQuery3 } from "@tanstack/react-query";
import { useMemo as useMemo4 } from "react";
function useAnyspendQuote(isMainnet2, req) {
  const { data, isLoading, refetch, error } = useQuery3({
    queryKey: ["useAnyspendQuote", isMainnet2, req],
    queryFn: () => {
      return anyspendService.getQuote(isMainnet2, req);
    },
    enabled: Boolean(
      req.srcChain && req.dstChain && req.srcTokenAddress && req.dstTokenAddress && BigInt(
        req.type === "swap" /* Swap */ ? req.amount : req.type === "mint_nft" /* MintNFT */ ? req.price : req.type === "join_tournament" /* JoinTournament */ ? req.price : req.type === "fund_tournament" /* FundTournament */ ? req.fundAmount : req.payload.amount
      ) !== BigInt(0)
    ),
    refetchInterval: 1e4,
    retry: false
  });
  return useMemo4(
    () => ({
      anyspendQuote: data,
      isLoadingAnyspendQuote: isLoading,
      getAnyspendQuoteError: error,
      refetchAnyspendQuote: refetch
    }),
    [data, error, isLoading, refetch]
  );
}

// src/hooks/useAnyspendSendPermitData.ts
import { useMutation as useMutation3 } from "@tanstack/react-query";
function useAnyspendSendPermitData({ onSuccess, onError } = {}) {
  const { mutate: sendPermitData, isPending } = useMutation3({
    mutationFn: async ({ isMainnet: isMainnet2, orderId, permitData }) => {
      try {
        const response = await anyspendService.sendPermitData({
          isMainnet: isMainnet2,
          orderId,
          permitData
        });
        if (response.statusCode !== 200) throw response;
        return response;
      } catch (error) {
        if (error.response?.data) {
          throw error.response.data;
        }
        throw error;
      }
    },
    onSuccess: (data) => {
      onSuccess?.(data);
    },
    onError: (error) => {
      onError?.(error);
    }
  });
  return {
    sendPermitData,
    isSendingPermitData: isPending
  };
}

// src/hooks/useAnyspendTokens.ts
import { useQuery as useQuery4 } from "@tanstack/react-query";
import { useMemo as useMemo5 } from "react";
function useAnyspendTokenList(isMainnet2, chainId, query) {
  const {
    data = [],
    isLoading,
    refetch
  } = useQuery4({
    queryKey: ["getAnyspendTokenList", chainId, query],
    queryFn: () => anyspendService.getTokenList(isMainnet2, chainId, query),
    enabled: true
  });
  return useMemo5(
    () => ({
      data,
      isLoading,
      refetch
    }),
    [data, isLoading, refetch]
  );
}

// src/hooks/useCoinbaseOnrampOptions.ts
import { useQuery as useQuery5 } from "@tanstack/react-query";
import { useMemo as useMemo6 } from "react";
function useCoinbaseOnrampOptions(isMainnet2, country) {
  const { data, isLoading, error, refetch } = useQuery5({
    queryKey: ["getCoinbaseOnrampOptions", isMainnet2, country],
    queryFn: () => anyspendService.getCoinbaseOnrampOptions(isMainnet2, country),
    enabled: Boolean(country)
  });
  return useMemo6(
    () => ({
      coinbaseOnrampOptions: data,
      isLoadingCoinbaseOnrampOptions: isLoading,
      coinbaseOnrampOptionsError: error,
      refetchCoinbaseOnrampOptions: refetch
    }),
    [data, isLoading, error, refetch]
  );
}

// src/hooks/useGeoOnrampOptions.ts
import { useMemo as useMemo8 } from "react";

// src/hooks/useGetGeo.ts
import { useQuery as useQuery6 } from "@tanstack/react-query";
async function fetchGeoData() {
  const response = await fetch("https://geo.basement.fun/");
  if (!response.ok) {
    throw new Error("Failed to fetch geo data");
  }
  return response.json();
}
function useGetGeo() {
  const {
    data: geoData,
    isLoading: loading,
    error
  } = useQuery6({ queryKey: ["useGetGeo"], queryFn: fetchGeoData, retry: 3 });
  return { geoData, loading, error };
}
var useGetGeo_default = useGetGeo;

// src/hooks/useStripeSupport.ts
import { useQuery as useQuery7 } from "@tanstack/react-query";
import { useMemo as useMemo7 } from "react";
function useStripeSupport(isMainnet2, ipAddress, usdAmount) {
  const { data, isLoading, error, refetch } = useQuery7({
    queryKey: ["useStripeSupport", isMainnet2, ipAddress, usdAmount],
    queryFn: () => anyspendService.checkStripeSupport(isMainnet2, ipAddress, usdAmount),
    enabled: !!ipAddress
  });
  return useMemo7(
    () => ({
      isStripeOnrampSupported: data?.stripeOnramp || false,
      isStripeWeb2Supported: data?.stripeWeb2 || false,
      isLoadingStripeSupport: isLoading,
      stripeSupportError: error,
      refetchStripeSupport: refetch
    }),
    [data, isLoading, error, refetch]
  );
}

// src/hooks/useGeoOnrampOptions.ts
function useGeoOnrampOptions(isMainnet2, srcFiatAmount) {
  const { geoData, loading: isLoadingGeo, error: geoError } = useGetGeo_default();
  const { coinbaseOnrampOptions, isLoadingCoinbaseOnrampOptions, coinbaseOnrampOptionsError } = useCoinbaseOnrampOptions(isMainnet2, geoData?.country);
  const { isStripeOnrampSupported, isStripeWeb2Supported, isLoadingStripeSupport, stripeSupportError } = useStripeSupport(isMainnet2, geoData?.ip || "", srcFiatAmount);
  const coinbaseAvailablePaymentMethods = useMemo8(() => {
    if (!coinbaseOnrampOptions?.paymentCurrencies?.[0]?.limits || !srcFiatAmount) return [];
    const amountNum = parseFloat(srcFiatAmount);
    if (isNaN(amountNum)) return [];
    return coinbaseOnrampOptions.paymentCurrencies[0].limits.filter((limit) => {
      const min = parseFloat(limit.min);
      const max = parseFloat(limit.max);
      return amountNum >= min && amountNum <= max;
    });
  }, [coinbaseOnrampOptions, srcFiatAmount]);
  return useMemo8(
    () => ({
      geoData,
      coinbaseOnrampOptions,
      coinbaseAvailablePaymentMethods,
      isStripeOnrampSupported,
      isStripeWeb2Supported,
      isOnrampSupported: coinbaseAvailablePaymentMethods.length > 0 || isStripeOnrampSupported || isStripeWeb2Supported,
      isLoading: isLoadingGeo || isLoadingCoinbaseOnrampOptions || isLoadingStripeSupport,
      isLoadingGeo,
      isLoadingCoinbaseOnrampOptions,
      isLoadingStripeSupport,
      geoError,
      coinbaseOnrampOptionsError,
      stripeSupportError
    }),
    [
      geoData,
      coinbaseOnrampOptions,
      coinbaseAvailablePaymentMethods,
      isStripeOnrampSupported,
      isStripeWeb2Supported,
      isLoadingGeo,
      isLoadingCoinbaseOnrampOptions,
      isLoadingStripeSupport,
      geoError,
      coinbaseOnrampOptionsError,
      stripeSupportError
    ]
  );
}

// src/hooks/usePermitData.ts
import { useQuery as useQuery8 } from "@tanstack/react-query";

// src/abis/abi-usdc-base.ts
var ABI_USDC_BASE = [
  {
    anonymous: false,
    inputs: [
      { indexed: true, internalType: "address", name: "owner", type: "address" },
      { indexed: true, internalType: "address", name: "spender", type: "address" },
      { indexed: false, internalType: "uint256", name: "value", type: "uint256" }
    ],
    name: "Approval",
    type: "event"
  },
  {
    anonymous: false,
    inputs: [
      { indexed: true, internalType: "address", name: "authorizer", type: "address" },
      { indexed: true, internalType: "bytes32", name: "nonce", type: "bytes32" }
    ],
    name: "AuthorizationCanceled",
    type: "event"
  },
  {
    anonymous: false,
    inputs: [
      { indexed: true, internalType: "address", name: "authorizer", type: "address" },
      { indexed: true, internalType: "bytes32", name: "nonce", type: "bytes32" }
    ],
    name: "AuthorizationUsed",
    type: "event"
  },
  {
    anonymous: false,
    inputs: [{ indexed: true, internalType: "address", name: "_account", type: "address" }],
    name: "Blacklisted",
    type: "event"
  },
  {
    anonymous: false,
    inputs: [{ indexed: true, internalType: "address", name: "newBlacklister", type: "address" }],
    name: "BlacklisterChanged",
    type: "event"
  },
  {
    anonymous: false,
    inputs: [
      { indexed: true, internalType: "address", name: "burner", type: "address" },
      { indexed: false, internalType: "uint256", name: "amount", type: "uint256" }
    ],
    name: "Burn",
    type: "event"
  },
  {
    anonymous: false,
    inputs: [{ indexed: true, internalType: "address", name: "newMasterMinter", type: "address" }],
    name: "MasterMinterChanged",
    type: "event"
  },
  {
    anonymous: false,
    inputs: [
      { indexed: true, internalType: "address", name: "minter", type: "address" },
      { indexed: true, internalType: "address", name: "to", type: "address" },
      { indexed: false, internalType: "uint256", name: "amount", type: "uint256" }
    ],
    name: "Mint",
    type: "event"
  },
  {
    anonymous: false,
    inputs: [
      { indexed: true, internalType: "address", name: "minter", type: "address" },
      { indexed: false, internalType: "uint256", name: "minterAllowedAmount", type: "uint256" }
    ],
    name: "MinterConfigured",
    type: "event"
  },
  {
    anonymous: false,
    inputs: [{ indexed: true, internalType: "address", name: "oldMinter", type: "address" }],
    name: "MinterRemoved",
    type: "event"
  },
  {
    anonymous: false,
    inputs: [
      { indexed: false, internalType: "address", name: "previousOwner", type: "address" },
      { indexed: false, internalType: "address", name: "newOwner", type: "address" }
    ],
    name: "OwnershipTransferred",
    type: "event"
  },
  { anonymous: false, inputs: [], name: "Pause", type: "event" },
  {
    anonymous: false,
    inputs: [{ indexed: true, internalType: "address", name: "newAddress", type: "address" }],
    name: "PauserChanged",
    type: "event"
  },
  {
    anonymous: false,
    inputs: [{ indexed: true, internalType: "address", name: "newRescuer", type: "address" }],
    name: "RescuerChanged",
    type: "event"
  },
  {
    anonymous: false,
    inputs: [
      { indexed: true, internalType: "address", name: "from", type: "address" },
      { indexed: true, internalType: "address", name: "to", type: "address" },
      { indexed: false, internalType: "uint256", name: "value", type: "uint256" }
    ],
    name: "Transfer",
    type: "event"
  },
  {
    anonymous: false,
    inputs: [{ indexed: true, internalType: "address", name: "_account", type: "address" }],
    name: "UnBlacklisted",
    type: "event"
  },
  { anonymous: false, inputs: [], name: "Unpause", type: "event" },
  {
    inputs: [],
    name: "CANCEL_AUTHORIZATION_TYPEHASH",
    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
    stateMutability: "view",
    type: "function"
  },
  {
    inputs: [],
    name: "DOMAIN_SEPARATOR",
    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
    stateMutability: "view",
    type: "function"
  },
  {
    inputs: [],
    name: "PERMIT_TYPEHASH",
    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
    stateMutability: "view",
    type: "function"
  },
  {
    inputs: [],
    name: "RECEIVE_WITH_AUTHORIZATION_TYPEHASH",
    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
    stateMutability: "view",
    type: "function"
  },
  {
    inputs: [],
    name: "TRANSFER_WITH_AUTHORIZATION_TYPEHASH",
    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
    stateMutability: "view",
    type: "function"
  },
  {
    inputs: [
      { internalType: "address", name: "owner", type: "address" },
      { internalType: "address", name: "spender", type: "address" }
    ],
    name: "allowance",
    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
    stateMutability: "view",
    type: "function"
  },
  {
    inputs: [
      { internalType: "address", name: "spender", type: "address" },
      { internalType: "uint256", name: "value", type: "uint256" }
    ],
    name: "approve",
    outputs: [{ internalType: "bool", name: "", type: "bool" }],
    stateMutability: "nonpayable",
    type: "function"
  },
  {
    inputs: [
      { internalType: "address", name: "authorizer", type: "address" },
      { internalType: "bytes32", name: "nonce", type: "bytes32" }
    ],
    name: "authorizationState",
    outputs: [