@funkit/api-base 1.0.2-next.0 → 1.0.2-next.2

package/dist/index.js

@@ -1,21 +1,1764 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
+// src/consts/api.ts
+var API_BASE_URL = false ? "https://api.fun.xyz/staging/v1" : false ? "https://api.fun.xyz/testing/v1" : false ? "http://127.0.0.1:3000" : (
+  // Production
+  "https://api.fun.xyz/v1"
+);
+var FUN_FAUCET_URL = "https://api.fun.xyz/demo-faucet";
+
+// src/errors/BaseError.ts
+var discord = "https://discord.gg/mvQunrx6NG";
+var BaseError = class extends Error {
+  constructor(baseType, type, code, msg, paramsUsed, fixSuggestion, docLink, isInternal = false) {
+    super(`${msg}
+
+${fixSuggestion}
+Docs: ${docLink}
+Discord: ${discord}`);
+    this.baseType = baseType;
+    this.type = type;
+    this.code = code;
+    this.paramsUsed = paramsUsed;
+    if (isInternal) {
+      this.loadEnd();
     }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./src/consts"), exports);
-__exportStar(require("./src/errors"), exports);
-__exportStar(require("./src/services"), exports);
-__exportStar(require("./src/utils"), exports);
-//# sourceMappingURL=index.js.map
+    this.message += "\n\nTrace:";
+    this.timestamp = (/* @__PURE__ */ new Date()).toUTCString();
+  }
+  loadEnd() {
+    this.message += "\n\nThis is an internal sdk error. Please contact the fun team at our Discord for the fastest response.";
+  }
+};
+
+// src/errors/errors.json
+var errors_default = {
+  AA21: {
+    info: " Your wallet lacks funds for this transaction.",
+    suggestion: "To fix this error, make sure you have enough funds in your wallet to cover the transaction fee."
+  },
+  FW000: {
+    info: " Create3Deployer.requireDeployerOnly() - Signatures were not sorted before being passed in",
+    suggestion: "To fix this error, make sure to short sigs before passing them into `requireDeployerOnly`. You can do this by calling `sigs.sort()` before passing them in. It is also possible to run into this error if the hash that was signed was not the correct hash."
+  },
+  FW001: {
+    info: " Create3Deployer.requireDeployerOnly() - Signature failed to be recovered. ercrecover returned the zero address",
+    suggestion: "To fix this error, make sure to pass in enough valid signatures that sign the `hash` in the `sigs` array"
+  },
+  FW002: {
+    info: " Create3Deployer.addDeployer() - Invalid Hash",
+    suggestion: "To fix this error, make sure `hash` is equal to `hashAddDeployer()`"
+  },
+  FW003: {
+    info: " Create3Deployer.removeDeployer() - Invalid Hash",
+    suggestion: "To fix this error, make sure `hash` is equal to `hashRemoveDeployer()`"
+  },
+  FW004: {
+    info: " Create3Deployer.setThreshold() - Threshold must be greater than 1",
+    suggestion: "To fix this error, `threshold` is greater than 1"
+  },
+  FW005: {
+    info: " Create3Deployer.setThreshold() - Invalid Hash",
+    suggestion: "To fix this error, make sure `hash` is equal to `keccak256(abi.encodePacked(_threshold))`"
+  },
+  FW006: {
+    info: " Create3Deployer.callChild() - Invalid Hash",
+    suggestion: "To fix this error, make sure `hash` is equal to `keccak256(abi.encodePacked(child, data, _nonce, block.chainid))`"
+  },
+  FW007: {
+    info: " Create3Deployer.callChild() - Invalid Nonce, nonce must be 1 greater than the current nonce",
+    suggestion: "To fix this error, make sure `_nonce` is equal to the current nonce + 1"
+  },
+  FW008: {
+    info: " Create3Deployer.callChild() - call to child failed",
+    suggestion: "To fix this error, check to see what is making the call to the child fail"
+  },
+  FW009: {
+    info: " Create3Deployer.deploy() - Invalid Hash",
+    suggestion: "To fix this error, make sure `hash` is equal to `keccak256(abi.encodePacked(_salt, _creationCode))`"
+  },
+  FW010: {
+    info: " FunWalletFactory.constructor() - Invalid Address, cannot be the zero address",
+    suggestion: "To fix this error, make sure `_deployer` is not equal to the zero address"
+  },
+  FW011: {
+    info: " FunWalletFactory.constructor() - Invalid Address, cannot be the zero address",
+    suggestion: "To fix this error, make sure `_funWalletImpAddress` is not equal to the zero address"
+  },
+  FW012: {
+    info: " FunWalletFactory.constructor() - Invalid Address, cannot be the zero address",
+    suggestion: "To fix this error, make sure `_feeOracle` is not equal to the zero address"
+  },
+  FW013: {
+    info: " FunWalletFactory.constructor() - Invalid Address, cannot be the zero address",
+    suggestion: "To fix this error, make sure `_walletInit` is not equal to the zero address"
+  },
+  FW014: {
+    info: " FunWalletFactory.constructor() - Unable to generate the address from this deployerSalt",
+    suggestion: "To fix this error, make sure `FunWalletFactoryV1` has not already been deployed from the given create3deployer contract. If it has been, change `FunWalletFactoryV1` to `FunWalletFactoryV2` or another version."
+  },
+  FW015: {
+    info: " FunWalletFactory.constructor() - Generated the wrong address from this deployerSalt",
+    suggestion: "To fix this error, make sure `FunWalletFactoryV1` has not already been deployed from the given create3deployer contract. If it has been, change `FunWalletFactoryV1` to `FunWalletFactoryV2` or another version."
+  },
+  FW016: {
+    info: " FunWalletFactory.createAccount() - Call to initialize failed on the deployed proxy",
+    suggestion: "To fix this error, make sure the `initializerCallData` is formatted correctly"
+  },
+  FW017: {
+    info: " FunWalletFactory - Caller must be deployer",
+    suggestion: "To fix this error, make sure to call the function from the deployer address"
+  },
+  FW018: {
+    info: " WalletInit.commit() - The previous commit has not expired",
+    suggestion: "To fix this error, wait for the previous commit with this `commitKey` to expire. This should take at most 10 minutes."
+  },
+  FW019: {
+    info: " WalletInit.validateSalt() - The hash at the commitKey does not match `keccak256(abi.encode(seed, owner, initializerCallData))`",
+    suggestion: "To fix this error, make sure the seed, owner, and initializerCallData are hashed and stored in commits at the corresponding `commitKey`"
+  },
+  FW020: {
+    info: " WalletInit.validateSalt() - The new owner of the funwallet must match data.newFunWalletOwner from loginData",
+    suggestion: "To fix this error, make sure the owner set in `loginData` matches the owner address returned from the tweet."
+  },
+  FW021: {
+    info: " WalletInit.setOracle() - The address of the new `_oracle` must not be the zero address",
+    suggestion: "To fix this error, make sure `_oracle` is not the zero address"
+  },
+  FW022: {
+    info: " Create3Deployer.deployFromChild() - Invalid Child Address",
+    suggestion: "To fix this error, make sure the caller is a contract deployed from the Create3Deployer"
+  },
+  FW023: {
+    info: " ImplementationRegistry.verifyIsValidContractAndImplementation() - Invalid Target Code Hash",
+    suggestion: "To fix this error, make sure the caller is a contract targeted is a ERC1967ProxyData contract"
+  },
+  FW024: {
+    info: " ImplementationRegistry.verifyIsValidContractAndImplementation() - Invalid Contract Implementation Address",
+    suggestion: "To fix this error, make sure you have the minimun threshold amount of valid signatures."
+  },
+  FW025: {
+    info: " ImplementationRegistry.addImplementation() - Invalid Signature Amount",
+    suggestion: "To fix this error, make sure you have the minimun threshold amount of valid signatures."
+  },
+  FW026: {
+    info: " ImplementationRegistry.removeImplementation() - Invalid Signature Amount",
+    suggestion: "To fix this error, make sure you have the minimun threshold amount of valid signatures."
+  },
+  FW027: {
+    info: " WalletInit.commit() - Unable to commit with a previously used commit hash",
+    suggestion: "To fix this error, make sure you are not reusing someone else's commit hash. If there are conflicts, just regenerate the seed randomly"
+  },
+  FW028: {
+    info: " MultiSigDeployer.constructor() - Threshold can't be greater than deployers length",
+    suggestion: "To fix this error, make sure the threshold value is not 0"
+  },
+  FW029: {
+    info: " WalletInit.invalidateUsedSeed() - msg.sender must equal funwalletfactory",
+    suggestion: "To fix this error, make sure you are calling this function from the FunWalletFactory contract"
+  },
+  FW030: {
+    info: " WalletInit.setFunWalletFactory() - funwalletfactory address cannot be set to 0",
+    suggestion: "To fix this error, make sure you are passing in the valid funwalletfactory address"
+  },
+  FW031: {
+    info: " WalletInit.validateSalt() - seed has already been used",
+    suggestion: "To fix this error, make sure you are not using an existing salt"
+  },
+  FW032: {
+    info: " FunWalletFactory.setFeeOracle() - Cannot set the fee oracle address to 0",
+    suggestion: "To fix this error, make sure you are using the correct address of the fee oracle"
+  },
+  FW033: {
+    info: " FunWalletFactory.constructor() - Invalid Address, cannot be the zero address",
+    suggestion: "To fix this error, make sure `_entryPoint` is not equal to the zero address"
+  },
+  FW034: {
+    info: " Create3Deployer.callChild() - Value not equal to msg.value",
+    suggestion: "To fix this error, make sure `msg.value` is equal to the `value` parameter."
+  },
+  FW100: {
+    info: " Module.execute() - execute() needs to be overriden",
+    suggestion: "To fix this error, make sure you are overriding the execute method in your module"
+  },
+  FW101: {
+    info: " ApproveAndExec.approveAndExecute() - the approveData's first four bytes must be the approve() function selector",
+    suggestion: "To fix this error, change `approveData` such that the first four bytes are `bytes4(keccak256('approve(address,uint256)'))`"
+  },
+  FW102: {
+    info: " ApproveAndSwap.constructor() - `_wethAddr` cannot be the zero address",
+    suggestion: "To fix this error, make sure `_wethAddr` is not set to the zero address"
+  },
+  FW103: {
+    info: " ApproveAndSwap.constructor() - `_router` cannot be the zero address",
+    suggestion: "To fix this error, make sure `_router` is not set to the zero address"
+  },
+  FW104: {
+    info: " ApproveAndSwap.executeSwapEth() - msg.sender does not have enough weth",
+    suggestion: "To fix this error, make sure msg.sender has a weth balance >= `amount`"
+  },
+  FW105: {
+    info: " ApproveAndSwap.\\_internalSwap() - Approve failed",
+    suggestion: "To fix this error, make sure you have formatted approve correctly"
+  },
+  FW106: {
+    info: " AaveWithdraw.execute() - Withdrawing a zero balance",
+    suggestion: "You are trying to withdraw from aave but don't have a balance"
+  },
+  FW107: {
+    info: " ApproveAndExec.approveAndExecute() - Approve failed",
+    suggestion: "The token you tried to approve failed"
+  },
+  FW108: {
+    info: " UniswapV3LimitOrder.execute() - Approval Failed",
+    suggestion: "You are trying to withdraw from aave but don't have a balance"
+  },
+  FW109: {
+    info: " UniswapV3LimitOrder.constructor() - Router cannot be address zero",
+    suggestion: "Make sure you are not passing in the zero address when initializing the module"
+  },
+  FW110: {
+    info: " UniswapV3LimitOrder.constructor() - Quoter cannot be zero address",
+    suggestion: "Make sure you are not passing in the zero address when initializing the module"
+  },
+  FW200: {
+    info: " FeePercentOracle.setValues() - feepercent must be less than or equals to 100%",
+    suggestion: "To fix this error, `_feepercent` must be less than or equals to `10 ** _decimals`"
+  },
+  FW201: {
+    info: " FeePercentOracle.withdrawEth() - eth transfer failed",
+    suggestion: "To fix this error, investigate why the eth withdrawal failed. This is likely because `amount` was greater than the eth balance in the FeePercentOracle"
+  },
+  FW202: {
+    info: " TokenPriceOracle.getTokenValueOfEth() - chainlink aggregator price must be greater than 0",
+    suggestion: "To fix this error, retry the call and make sure price is greater than 0"
+  },
+  FW203: {
+    info: " TokenPriceOracle.getTokenValueOfEth() - chainlink aggregator updatedAt must be greater than 0",
+    suggestion: "To fix this error, retry the call and make sure updatedAt is greater than 0"
+  },
+  FW204: {
+    info: " TokenPriceOracle.getTokenValueOfEth() - chainlink aggregator answeredInRound must be greater than or equal to roundId",
+    suggestion: "To fix this error, retry the call and make sure answeredInRound must be greater than or equal to roundId"
+  },
+  FW205: {
+    info: " TwitterOracle.batchSetTweet() - socialHandles, loginTypes, seeds, owners length must match in length",
+    suggestion: "To fix this error, make sure all arrays passed into this function are the same length."
+  },
+  FW206: {
+    info: " TwitterOracle.setTweet() - the seed from twitter cannot be empty",
+    suggestion: "To fix this error, make sure the seed you post on twitter is not empty {}"
+  },
+  FW207: {
+    info: " TwitterOracle.setTweet() - the address from twitter cannot be 0",
+    suggestion: "To fix this error, make sure the address you post on twitter for the new owner is not the zero address, otherwise you would be unable to claim ownership of the funwallet"
+  },
+  FW208: {
+    info: " TwitterOracle.batchSetTweet() - the seed from twitter cannot be empty",
+    suggestion: "To fix this error, make sure the seed you post on twitter is not empty {}"
+  },
+  FW209: {
+    info: " TwitterOracle.batchSetTweet() - the address from twitter cannot be 0",
+    suggestion: "To fix this error, make sure the address you post on twitter for the new owner is not the zero address, otherwise you would be unable to claim ownership of the funwallet"
+  },
+  FW210: {
+    info: " TwitterOracle.fetchTweet() - the seed from twitter cannot be empty",
+    suggestion: "To fix this error, make sure the seed you post on twitter is not empty {}"
+  },
+  FW211: {
+    info: " TwitterOracle.fetchTweet() - the address from twitter cannot be 0",
+    suggestion: "To fix this error, make sure the address you post on twitter for the new owner is not the zero address, otherwise you would be unable to claim ownership of the funwallet"
+  },
+  FW300: {
+    info: " BasePaymaster.constructor() - entrypoint address cannot be the zero address",
+    suggestion: "To fix this error, make sure entrypoint address is not the zero address"
+  },
+  FW301: {
+    info: " BasePaymaster.\\_requireFromEntryPoint() - the msg.sender must be from the entrypoint",
+    suggestion: "To fix this error, make sure the msg.sender must be from the entrypoint"
+  },
+  FW302: {
+    info: " GaslessPaymaster.batchActions() - the ith delegate call failed",
+    suggestion: "To fix this error, make sure the calldata for `data[i]` is a valid call"
+  },
+  FW303: {
+    info: " GaslessPaymaster.batchActions() - batchActions consumed more eth than `msg.value` allocated",
+    suggestion: "To fix this error, increase the amount of msg.value you are passing to this function"
+  },
+  FW304: {
+    info: " GaslessPaymaster.\\_withdrawDepositTo() - the withdrawal has not been unlocked",
+    suggestion: "To fix this error, wait till block.number is greater than the unlockBlock for the sender and make sure `unlockBlock[sender]` is nonzero"
+  },
+  FW305: {
+    info: " GaslessPaymaster.\\_withdrawDepositTo() - the balances of the sender must be greater than the withdrawal amount",
+    suggestion: "To fix this error, decrease the amount you are trying to withdraw"
+  },
+  FW306: {
+    info: " GaslessPaymaster.\\_validatePaymasterUserOp() - the userOp.paymasterAndData must have a length of 40",
+    suggestion: "To fix this error, change the `paymasterAndData` field in the `userOp` such that the length is 40"
+  },
+  FW307: {
+    info: " GaslessPaymaster.\\_validatePaymasterUserOp() - the verificationGasLimit must be greater than the `COST_OF_POST` variable in GaslessPaymaster",
+    suggestion: "To fix this error, increase the `verificationGasLimit` in the `userOp`"
+  },
+  FW308: {
+    info: " GaslessPaymaster.\\_validatePaymasterUserOp() - the sponsor's eth is not locked for use",
+    suggestion: "To fix this error, make sure the sponsor's eth is locked using `lockDeposit()`"
+  },
+  FW309: {
+    info: " GaslessPaymaster.\\_validatePaymasterUserOp() - The sponsor needs to approve the spender",
+    suggestion: "To fix this error, make sure to approve the spender using `setSpenderWhitelistMode()` or `setSpenderBlacklistMode()` and the sponsor's list mode is set to whitelist mode or blacklist mode using `setListMode()"
+  },
+  FW310: {
+    info: " GaslessPaymaster.\\_validatePaymasterUserOp() - The sponsor does not have sufficient eth in the paymaster to cover this operation",
+    suggestion: "To fix this error, make sure to stake enough eth from the sponsor's address using `addDepositTo()`"
+  },
+  FW311: {
+    info: " GaslessPaymaster.addDepositTo() - `msg.value` must be greater than or equal to amount",
+    suggestion: "To fix this error, make sure `msg.value` must be greater than or equal to amount"
+  },
+  FW312: {
+    info: " TokenPaymaster.batchActions() - the ith delegate call failed",
+    suggestion: "To fix this error, make sure the calldata for `data[i]` is a valid call"
+  },
+  FW313: {
+    info: " TokenPaymaster.batchActions() - batchActions consumed more eth than `msg.value` allocated",
+    suggestion: "To fix this error, increase the amount of msg.value you are passing to this function"
+  },
+  FW314: {
+    info: " TokenPaymaster.\\_addTokenDepositTo() - token decimals must be greater than 0",
+    suggestion: "To fix this error, change the decimals in token using `setTokenData()`"
+  },
+  FW315: {
+    info: " TokenPaymaster.\\_withdrawTokenDepositTo() - token is not unlocked for withdrawal",
+    suggestion: "To fix this error, call `unlockTokenDepositAfter()`"
+  },
+  FW316: {
+    info: " TokenPaymaster.\\_withdrawTokenDepositTo() - you are withdrawing more tokens that you have in balance",
+    suggestion: "To fix this error, call `getTokenBalance()` to check how many tokens you have and make sure `amount` is less than that"
+  },
+  FW317: {
+    info: " TokenPaymaster.\\_withdrawEthDepositTo() - token is not unlocked for withdrawal",
+    suggestion: "To fix this error, call `unlockTokenDepositAfter()` with `ETH` as the token"
+  },
+  FW318: {
+    info: " TokenPaymaster.\\_withdrawEthDepositTo() - you are withdrawing more ether that you have in balance",
+    suggestion: "To fix this error, call `getTokenBalance()` with `ETH` as the token to check how many tokens you have and make sure `amount` is less than that"
+  },
+  FW319: {
+    info: " TokenPaymaster.\\_getTokenValueOfEth() - call to token oracle failed",
+    suggestion: "To fix this error, check the token oracle and call `setTokenData()` to change the oracle if it is broken"
+  },
+  FW320: {
+    info: " TokenPaymaster.\\_reimbursePaymaster() - failed to reimbursePaymaster with tokens via `permitTransfer()`",
+    suggestion: "To fix this **error**, make sure you have permitted the paymaster to spend your tokens"
+  },
+  FW321: {
+    info: " TokenPaymaster.\\_reimbursePaymaster() - spender doesn't have enough tokens",
+    suggestion: "To fix this error, make sure to add more tokens to the token paymaster via `addTokenDepositTo()`"
+  },
+  FW322: {
+    info: " TokenPaymaster.\\_validatePaymasterUserOp() - `paymasterAndData` length must be 60",
+    suggestion: "To fix this error, make sure to set `paymasterAndData` length to be 60"
+  },
+  FW323: {
+    info: " TokenPaymaster.\\_validatePaymasterUserOp() - `verificationGasLimit` must be greater than `COST_OF_POST`",
+    suggestion: "To fix this error, make sure to set the userOp's `verificationGasLimit` to be greater than `COST_OF_POST`"
+  },
+  FW324: {
+    info: " TokenPaymaster.\\_validatePaymasterUserOp() - the sponsor must lock their ETH",
+    suggestion: "To fix this error, make sure the sponsor has locked their eth by calling `lockTokenDeposit()` from the sponsor address"
+  },
+  FW325: {
+    info: " TokenPaymaster.\\_validatePaymasterUserOp() - the account must lock their tokens",
+    suggestion: "To fix this error, make sure the user of the token paymaster has locked their tokens by calling `lockTokenDeposit()` from their address"
+  },
+  FW326: {
+    info: " TokenPaymaster.\\_validatePaymasterUserOp() - the sponsor eth balance must be greater than maxCost",
+    suggestion: "To fix this error, make sure the sponsor eth balance is greater than maxCost"
+  },
+  FW327: {
+    info: " TokenPaymaster.\\_validatePaymasterUserOp() - the sponsor must approve the spender",
+    suggestion: "To fix this error, make sure the sponsor has approved the spender by calling `setSpenderWhitelistMode()` or `setSpenderBlacklistMode()` and the sponsor's list mode is set to whitelist mode or blacklist mode using `setListMode()`"
+  },
+  FW328: {
+    info: " TokenPaymaster.\\_validatePaymasterUserOp() - the sponsor must have approved the token to the paymaster",
+    suggestion: "To fix this error, make sure the sponsor has approved the spender by calling `setTokenWhitelistMode()` or `setTokenBlacklistMode()` and the sponsor's list mode is set to whitelist mode or blacklist mode using `setTokenListMode()`"
+  },
+  FW329: {
+    info: " TokenPaymaster.\\_validatePaymasterUserOp() - the permitted token must be equal to the token you are trying to pay with if using permit",
+    suggestion: "To fix this error, make sure the permitted token is equal to the token you are trying to pay with if using permit"
+  },
+  FW330: {
+    info: " TokenPaymaster.\\_validatePaymasterUserOp() - the permitted transfer recipient must be the token paymaster",
+    suggestion: "To fix this error, make sure to permit the token paymaster to spend your tokens"
+  },
+  FW331: {
+    info: " TokenPaymaster.\\_validatePaymasterUserOp() - the permitted transfer amount must be greater than or equal to the maxTokenCost",
+    suggestion: "To fix this error, make sure the permitted transfer amount is greater than or equal to the maxTokenCost"
+  },
+  FW332: {
+    info: " TokenPaymaster.\\_validatePaymasterUserOp() - if permit was not used, make sure the tokenPaymaster was approved to spend tokens by the sponsor or enough tokens were deposited into the TokenPaymaster",
+    suggestion: "To fix this error, make sure the tokenPaymaster was approved(`approve()`) to spend tokens by the sponsor or enough tokens were deposited into the TokenPaymaster via `addTokenDepositTo()`"
+  },
+  FW333: {
+    info: " TokenPaymaster.addEthDepositTo() - make sure msg.value is greater than or equal to amount",
+    suggestion: "To fix this error, make sure that the msg.value is greater than or equal to amount"
+  },
+  FW334: {
+    info: " TokenPaymaster.addTokenDepositTo() - sponsor cannot be the zero address",
+    suggestion: "To fix this error, make sure the sponsor is not the zero address"
+  },
+  FW335: {
+    info: " TokenPaymaster.addTokenDepositTo() - target cannot be the zero address",
+    suggestion: "To fix this error, make sure the target is not the zero address"
+  },
+  FW336: {
+    info: " TokenPaymaster.addTokenDepositTo() - token address cannot be the zero address",
+    suggestion: "To fix this error, make sure the token address is not the zero address"
+  },
+  FW337: {
+    info: " TokenPaymaster.addTokenDepositTo() - spender address cannot be the zero address",
+    suggestion: "To fix this error, make sure the spender address is not the zero address"
+  },
+  FW338: {
+    info: " TokenPaymaster.addTokenDepositTo() - the token oracle cannot be the zero address",
+    suggestion: "To fix this error, make sure the token oracle is not the zero address"
+  },
+  FW339: {
+    info: " TokenPaymaster.addTokenDepositTo() - the tokenAddress cannot be the zero address",
+    suggestion: "To fix this error, make sure the tokenAddress is not the zero address"
+  },
+  FW340: {
+    info: " TokenPaymaster.addTokenDepositTo() - the token decimals must be greater than 0",
+    suggestion: "To fix this error, make sure the token decimals is greater than 0"
+  },
+  FW341: {
+    info: " TokenPaymaster.addTokenDepositTo() - the chainlink aggregator cannot be the zero address",
+    suggestion: "To fix this error, make sure the chainlink aggregator is not the zero address"
+  },
+  FW342: {
+    info: " TokenPaymaster.removeTokenData() - The token doesn't exist in tokens",
+    suggestion: "To fix this error, make sure the token address is not the zero address"
+  },
+  FW343: {
+    info: " TokenPaymaster.removeTokenData() - The tokenListIndex doesn't match with the tokenAddress",
+    suggestion: "To fix this error, make sure the token at tokenList[tokenListIndex] is the same as the tokenAddress"
+  },
+  FW344: {
+    info: " GaslessPaymaster.batchActions() - Cannot recursively call batchActions from within batchActions",
+    suggestion: "To fix this error, make sure you are not recursively calling batchActions from within batchActions"
+  },
+  FW345: {
+    info: " TokenPaymaster.batchActions() - Cannot recursively call batchActions from within batchActions",
+    suggestion: "To fix this error, make sure you are not recursively calling batchActions from within batchActions"
+  },
+  FW346: {
+    info: " TokenPaymaster.postOp() - Invalid Permit transfer amount",
+    suggestion: "To fix this error, make sure your permit transfer has transfered the correct amount of tokens"
+  },
+  FW347: {
+    info: " TokenPaymaster.\\_reimbursePaymaster() - Invalid amount of tokens transferred",
+    suggestion: "The likely cause of this error is using a deflationary token that charges a tax when you transfer tokens. To fix this error, make sure you are transferring the correct amount of tokens and to account for the tax/deflation."
+  },
+  FW348: {
+    info: " UserAuthentication.init() - groupId count must be equal to groups length",
+    suggestion: "Make sure the number of groupIds equals the number of groups."
+  },
+  FW349: {
+    info: " TokenPaymaster.calculatePostOpGas() - Invalid Auth Type",
+    suggestion: "Make sure the authtype is correct"
+  },
+  FW350: {
+    info: " TokenPaymaster.\\_validatePaymasterUserOp() - Does not have enough balance of token",
+    suggestion: "To fix this error, make sure your has enough tokens to permit transfer"
+  },
+  FW351: {
+    info: " BasePaymaster.\\withdrawStakeFromEntryPoint() - Cannot withdraw to address zero",
+    suggestion: "To fix this error, make sure you are not withdrawing to address zero"
+  },
+  FW401: {
+    info: " RoleBasedAccessControl",
+    suggestion: "### `FW402`: RoleBasedAccessControl.isValidAction(), isValidActionAndFee() - Invalid Target"
+  },
+  FW402: {
+    info: " RoleBasedAccessControl.isValidAction(), isValidActionAndFee() - Invalid Target",
+    suggestion: "To fix this error, make sure the target that you are calling is in the merkle root of allowed targets verified by the rule. If this does not work make sure you are using the correct merkle root implementation."
+  },
+  FW403: {
+    info: " RoleBasedAccessControl",
+    suggestion: "To fix this error, make sure the selector that you are calling is in the merkle root of allowed selector verified by the rule. If this does not work make sure you are using the correct merkle root implementation."
+  },
+  FW404: {
+    info: " RoleBasedAccessControl",
+    suggestion: "To fix this error, make sure the ownerId is not 0 or an existing owner"
+  },
+  FW405: {
+    info: " RoleBasedAccessControl",
+    suggestion: "To fix this error, make sure the ruleId is not 0"
+  },
+  FW406: {
+    info: " RoleBasedAccessControl",
+    suggestion: "To fix this error, make sure the rule that you are using has a deadline that has passed."
+  },
+  FW408: {
+    info: " RoleBasedAccessControl",
+    suggestion: "### `FW410`: RoleBasedAccessControl: isValidAction(), isValidActionAndFee() - Rule not added to role"
+  },
+  FW410: {
+    info: " RoleBasedAccessControl",
+    suggestion: "To fix this error, make sure the rule is added to the role"
+  },
+  FW411: {
+    info: " RoleBasedAccessControl",
+    suggestion: "To fix this error, make sure the value for the execution call is less than the limit"
+  },
+  FW412: {
+    info: " RoleBasedAccessControl",
+    suggestion: "To fix this error, make sure the fee value for the execution call is less than the limit"
+  },
+  FW413: {
+    info: " RoleBasedAccessControl",
+    suggestion: "To fix this error, make sure the fee recipient is in the rule fee merkle root"
+  },
+  FW414: {
+    info: " RoleBasedAccessControl",
+    suggestion: "To fix this error, make sure the fee token is in the rule fee merkle root"
+  },
+  FW417: {
+    info: " RoleBasedAccessControl",
+    suggestion: "To fix this error, make sure the rule you are using exists"
+  },
+  FW418: {
+    info: " RoleBasedAccessControl",
+    suggestion: "To fix this error, make sure the user is in the role"
+  },
+  FW419: {
+    info: " RoleBasedAccessControl",
+    suggestion: "To fix this error, make sure the feeRecipientTokenMerkleRootHash is not zero"
+  },
+  FW420: {
+    info: " RoleBasedAccessControl",
+    suggestion: "To fix this error, make sure the targetSelectorMerkleRootHash is not zero"
+  },
+  FW421: {
+    info: " RoleBasedAccessControl",
+    suggestion: "### `FW422`: RoleBasedAccessControl: init() - Wallet has not been initialized"
+  },
+  FW422: {
+    info: " RoleBasedAccessControl",
+    suggestion: "To fix this error, make sure the wallet has not initialized the validation contract"
+  },
+  FW500: {
+    info: " FunWallet.initialize() - the entrypoint cannot be the zero address",
+    suggestion: "To fix this error, make sure the entrypoint is not the zero address"
+  },
+  FW501: {
+    info: " FunWallet.initialize() - the msg.sender cannot be the address of the Funwallet contract",
+    suggestion: "To fix this error, make sure the msg.sender is not the address of the Funwallet contract"
+  },
+  FW502: {
+    info: " FunWallet.\\_requireFromFunWalletProxy() - the function must be called from the funwallet proxy",
+    suggestion: "To fix this error, make sure the msg.sender == funwallet"
+  },
+  FW503: {
+    info: " FunWallet.updateEntryPoint() - the new entrypoint address cannot be the zero address",
+    suggestion: "To fix this error, make sure the new entrypoint address is not the zero address"
+  },
+  FW504: {
+    info: " FunWallet.depositToEntryPoint() - not enough eth in the funwallet",
+    suggestion: "To fix this error, make sure the funwallet has more than the amount of eth you are trying to deposit"
+  },
+  FW505: {
+    info: " FunWallet.\\_transferEthFromEntrypoint() - withdrawing eth from the entrypoint failed",
+    suggestion: "To fix this error, retry the operation and make sure you have greater than amount balance in the entrypoint"
+  },
+  FW506: {
+    info: " FunWallet.\\_requireFromModule() - make sure a funwalletfactory deployed the module",
+    suggestion: "To fix this error, make sure the msg.sender is the module"
+  },
+  FW507: {
+    info: " FunWallet.\\_requireFromEntryPoint() - the msg.sender must be the entrypoint",
+    suggestion: "To fix this error, make sure the msg.sender is the entrypoint"
+  },
+  FW508: {
+    info: " WalletFee.\\_transferEth() - the eth transfer failed",
+    suggestion: "To fix this error, retry the operation and make sure you have greater than amount balance in the wallet"
+  },
+  FW509: {
+    info: " WalletFee.\\_handleFee() - the developer eth transfer failed",
+    suggestion: "To fix this error, retry the operation and make sure you have greater than amount balance in the wallet"
+  },
+  FW510: {
+    info: " WalletFee.\\_handleFee() - the funOracle eth transfer failed",
+    suggestion: "To fix this error, retry the operation and make sure you have greater than amount balance in the wallet"
+  },
+  FW511: {
+    info: " WalletValidation.initValidations() - the WalletValidations contract has already been initialized",
+    suggestion: "Don't call initValidations() more than once"
+  },
+  FW512: {
+    info: " WalletValidation.initValidations() - make sure there are more than zero validations",
+    suggestion: "To fix this error, make sure there are more than zero validations and the number of validation contract addresses are equal to the number of `initCallData` elements"
+  },
+  FW513: {
+    info: " WalletValidation.initValidations() - make sure there are no duplicate validation contract addresses",
+    suggestion: "To fix this error, make sure there are no duplicate validation contract addresses in `validationData`"
+  },
+  FW514: {
+    info: " WalletValidation.\\_validateUserOp() - make sure the signature length is greater than 0",
+    suggestion: "To fix this error, make sure the signature length is greater than 0"
+  },
+  FW515: {
+    info: " WalletValidation.isValidSignature() - make sure the number of validations is greater than zero",
+    suggestion: "To fix this error, make sure the number of validations is greater than zero"
+  },
+  FW516: {
+    info: " WalletValidation.\\_requireValidValidation() - the validation failed",
+    suggestion: "To fix this error, make sure the validation contract returns true"
+  },
+  FW517: {
+    info: " WalletValidation.\\_requireValidValidationFormat() - the validation was incorrectly formatted",
+    suggestion: "To fix this error, make sure the validation contract address is not the zero address and the validation is valid and the address is not the zero address"
+  },
+  FW518: {
+    info: " WalletValidation.\\_requireValidPrevValidation() - the previous validation must be linked to this validation",
+    suggestion: "To fix this error, make sure the previous validation is linked to this validation when adding or removing the validation"
+  },
+  FW519: {
+    info: " WalletValidation.getValidations() - you must have more than zero validations to get validations",
+    suggestion: "To fix this error, make sure there are a nonzero amount of validations"
+  },
+  FW520: {
+    info: " WalletValidation.addValidation() - The caller must be this wallet.",
+    suggestion: "To fix this error, make sure you are calling addValidation() from your funwallet."
+  },
+  FW521: {
+    info: " WalletValidation.removeValidation() - The caller must be this wallet.",
+    suggestion: "To fix this error, make sure you are calling removeValidation() from your funwallet."
+  },
+  FW522: {
+    info: " WalletValidation.updateValidation() - The caller must be this wallet.",
+    suggestion: "To fix this error, make sure you are calling updateValidation() from your funwallet."
+  },
+  FW523: {
+    info: " WalletModules.permitTransfer() - Invalid Permit Signature.",
+    suggestion: "To fix this error, make sure you have a valid permit signature."
+  },
+  FW524: {
+    info: " WalletValidation.getValidations() - No Validations in the wallet",
+    suggestion: "To fix this error, make sure the wallet has validation contracts"
+  },
+  FW600: {
+    info: " DataLib",
+    suggestion: "To fix this error, make sure you are calling either execFromEntryPoint() or execFromEntryPointWithFee() from your funwallet."
+  },
+  FW601: {
+    info: " Ownable2StepNoRenounce",
+    suggestion: "To fix this error, don't call this function."
+  }
+};
+
+// src/errors/types.ts
+var ErrorBaseType = /* @__PURE__ */ ((ErrorBaseType2) => {
+  ErrorBaseType2["ClientError"] = "ClientError";
+  ErrorBaseType2["ServerError"] = "ServerError";
+  return ErrorBaseType2;
+})(ErrorBaseType || {});
+var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
+  ErrorType2["InvalidParameter"] = "InvalidParameter";
+  ErrorType2["InternalServerFailure"] = "InternalServerFailure";
+  ErrorType2["ResourceNotFound"] = "ResourceNotFound";
+  ErrorType2["InvalidAction"] = "InvalidAction";
+  ErrorType2["ThrottlingError"] = "ThrottlingError";
+  ErrorType2["AccessDeniedError"] = "AccessDeniedError";
+  ErrorType2["UserOpFailureError"] = "UserOpFailureError";
+  return ErrorType2;
+})(ErrorType || {});
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2["MissingParameter"] = "MissingParameter";
+  ErrorCode2["InvalidParameter"] = "InvalidParameter";
+  ErrorCode2["InvalidThreshold"] = "InvalidThreshold";
+  ErrorCode2["InvalidChainIdentifier"] = "InvalidChainIdentifier";
+  ErrorCode2["InvalidNFTIdentifier"] = "InvalidNFTIdentifier";
+  ErrorCode2["InsufficientSignatures"] = "InsufficientSignatures";
+  ErrorCode2["InvalidParameterCombination"] = "InvalidParameterCombination";
+  ErrorCode2["CheckPointHintsNotFound"] = "CheckPointHintsNotFound";
+  ErrorCode2["GroupNotFound"] = "GroupNotFound";
+  ErrorCode2["TokenNotFound"] = "TokenNotFound";
+  ErrorCode2["AddressNotFound"] = "AddressNotFound";
+  ErrorCode2["UserAlreadyExists"] = "UserAlreadyExists";
+  ErrorCode2["UserNotFound"] = "UserNotFound";
+  ErrorCode2["ChainNotSupported"] = "ChainNotSupported";
+  ErrorCode2["ServerMissingData"] = "ServerMissingData";
+  ErrorCode2["ServerFailure"] = "ServerFailure";
+  ErrorCode2["ServerTimeout"] = "ServerTimeout";
+  ErrorCode2["UnknownServerError"] = "UnknownServerError";
+  ErrorCode2["ServerConnectionError"] = "ServerConnectionError";
+  ErrorCode2["UserOpFailureError"] = "UserOpFailureError";
+  ErrorCode2["Unauthorized"] = "Unauthorized";
+  ErrorCode2["RequestLimitExceeded"] = "RequestLimitExceeded";
+  ErrorCode2["WalletPrefundError"] = "PrefundError";
+  ErrorCode2["GasSponsorFundError"] = "GasSponsorFundError";
+  ErrorCode2["FunWalletErrorCode"] = "FunWalletErrorCode";
+  ErrorCode2["BridgeRouteNotFound"] = "BridgeRouteNotFound";
+  ErrorCode2["BridgeAllowanceDataNotFound"] = "BridgeAllowanceDataNotFound";
+  ErrorCode2["BridgeApproveTxDataNotFound"] = "BridgeApproveTxDataNotFound";
+  ErrorCode2["CheckoutInitDepositAddrNotFound"] = "CheckoutInitDepositAddrNotFound";
+  return ErrorCode2;
+})(ErrorCode || {});
+
+// src/errors/ClientError.ts
+var ClientError = class extends BaseError {
+  constructor(type, code, msg, paramsUsed, fixSuggestion, docLink) {
+    super(
+      "ClientError" /* ClientError */,
+      type,
+      code,
+      msg,
+      paramsUsed,
+      fixSuggestion,
+      docLink,
+      false
+    );
+  }
+};
+var InvalidParameterError = class extends ClientError {
+  constructor(code, msg, paramsUsed, fixSuggestion, docLink) {
+    super(
+      "InvalidParameter" /* InvalidParameter */,
+      code,
+      msg,
+      paramsUsed,
+      fixSuggestion,
+      docLink
+    );
+  }
+};
+var ResourceNotFoundError = class extends ClientError {
+  constructor(code, msg, paramsUsed, fixSuggestion, docLink) {
+    if (msg.includes("Chain name not found")) {
+      const { reqId } = JSON.parse(msg);
+      msg = ": Chain name not found or not supported.";
+      fixSuggestion = "Change your EnvOptions to the correct chain identifier.";
+      super(
+        "ResourceNotFound" /* ResourceNotFound */,
+        "ChainNotSupported" /* ChainNotSupported */,
+        msg,
+        { reqId },
+        fixSuggestion,
+        docLink
+      );
+    } else {
+      super(
+        "ResourceNotFound" /* ResourceNotFound */,
+        code,
+        msg,
+        paramsUsed,
+        fixSuggestion,
+        docLink
+      );
+    }
+  }
+};
+var InvalidActionError = class extends ClientError {
+  constructor(code, msg, paramsUsed, fixSuggestion, docLink) {
+    super(
+      "InvalidAction" /* InvalidAction */,
+      code,
+      msg,
+      paramsUsed,
+      fixSuggestion,
+      docLink
+    );
+  }
+};
+var ThrottlingError = class extends ClientError {
+  constructor(code, msg, paramsUsed, fixSuggestion, docLink) {
+    super(
+      "ThrottlingError" /* ThrottlingError */,
+      code,
+      msg,
+      paramsUsed,
+      fixSuggestion,
+      docLink
+    );
+  }
+};
+var AccessDeniedError = class extends ClientError {
+  constructor(code, msg, paramsUsed, fixSuggestion, docLink) {
+    super(
+      "AccessDeniedError" /* AccessDeniedError */,
+      code,
+      msg,
+      paramsUsed,
+      fixSuggestion,
+      docLink
+    );
+  }
+};
+var UserOpFailureError = class extends ClientError {
+  constructor(code, msg, paramsUsed, fixSuggestion, docLink) {
+    const FWCode = findFWContractError(msg);
+    if (FWCode) {
+      const { reqId } = JSON.parse(msg);
+      msg = errors_default[FWCode].info;
+      fixSuggestion = errors_default[FWCode].suggestion;
+      super(
+        "UserOpFailureError" /* UserOpFailureError */,
+        "FunWalletErrorCode" /* FunWalletErrorCode */,
+        msg,
+        { reqId },
+        fixSuggestion,
+        docLink
+      );
+    } else {
+      super(
+        "UserOpFailureError" /* UserOpFailureError */,
+        code,
+        msg,
+        paramsUsed,
+        fixSuggestion,
+        docLink
+      );
+    }
+  }
+};
+var findFWContractError = (msg) => {
+  let match = msg.match(/FW\d{3}/);
+  if (!match) {
+    match = msg.match(/AA\d./);
+  }
+  return match?.[0];
+};
+
+// src/errors/ServerError.ts
+var ServerError = class extends BaseError {
+  constructor(type, code, msg, paramsUsed, fixSuggestion, docLink) {
+    super(
+      "ServerError" /* ServerError */,
+      type,
+      code,
+      msg,
+      paramsUsed,
+      fixSuggestion,
+      docLink,
+      true
+    );
+  }
+};
+var InternalFailureError = class extends ServerError {
+  constructor(code, msg, paramsUsed, fixSuggestion, docLink) {
+    super(
+      "InternalServerFailure" /* InternalServerFailure */,
+      code,
+      msg,
+      paramsUsed,
+      fixSuggestion,
+      docLink
+    );
+  }
+};
+
+// src/utils/error.ts
+var errorAbortHandler = (err, context) => {
+  if (err instanceof ResourceNotFoundError || err instanceof InvalidParameterError || err instanceof UserOpFailureError) {
+    context.abort();
+  }
+};
+
+// src/consts/retry.ts
+var DEFAULT_RETRY_OPTIONS = {
+  delay: 100,
+  initialDelay: 0,
+  maxDelay: 3e3,
+  factor: 2,
+  maxAttempts: 5,
+  timeout: 0,
+  jitter: true,
+  minDelay: 0,
+  handleError: errorAbortHandler,
+  handleTimeout: null,
+  beforeAttempt: null,
+  calculateDelay: null
+};
+
+// src/utils/checkout.ts
+import { toHex } from "viem";
+function randomBytes(length) {
+  const bytes = new Uint8Array(length);
+  for (let i = 0; i < length; i++) {
+    bytes[i] = Math.floor(Math.random() * 256);
+  }
+  return toHex(bytes);
+}
+function generateRandomCheckoutSalt() {
+  return toHex(BigInt(randomBytes(32)));
+}
+function roundToNearestBottomTenth(n) {
+  return Math.floor(n / 10) * 10;
+}
+
+// src/utils/request.ts
+import { retry } from "@lifeomic/attempt";
+import { toHex as toHex2 } from "viem";
+var stringifyWithBigIntSanitization = (object) => {
+  return JSON.stringify(
+    object,
+    (_, value) => typeof value === "bigint" ? toHex2(value) : value
+    // return everything else unchanged
+  );
+};
+var sendRequest = async ({
+  uri,
+  method,
+  apiKey,
+  body = {},
+  retryOptions = {}
+}) => {
+  try {
+    const headers = {
+      "Content-Type": "application/json",
+      ...apiKey ? { "X-Api-Key": apiKey } : {}
+    };
+    const finalRetryOptions = {
+      ...DEFAULT_RETRY_OPTIONS,
+      ...retryOptions || {}
+    };
+    return retry(async function() {
+      const response = await fetch(uri, {
+        method,
+        headers,
+        redirect: "follow",
+        body: method !== "GET" ? stringifyWithBigIntSanitization(body) : void 0
+      });
+      const json = await response.json();
+      if (response.ok) {
+        return json;
+      } else if (response.status === 400) {
+        throw new InvalidParameterError(
+          "InvalidParameter" /* InvalidParameter */,
+          `bad request ${JSON.stringify(json)}`,
+          { body },
+          "check the api call parameters. its mostly because some call parameters are wrong",
+          "https://docs.fun.xyz"
+        );
+      } else if (response.status === 403) {
+        throw new AccessDeniedError(
+          "Unauthorized" /* Unauthorized */,
+          "Invalid API key or insufficient access.",
+          { apiKey },
+          "Check your api key at https://app.fun.xyz and check with fun team if you believe something is off",
+          "https://docs.fun.xyz"
+        );
+      } else if (response.status === 404) {
+        throw new ResourceNotFoundError(
+          "ServerMissingData" /* ServerMissingData */,
+          JSON.stringify(json),
+          { body },
+          "check the api call parameters. its mostly because some call parameters are wrong",
+          "https://docs.fun.xyz"
+        );
+      } else if (response.status === 429) {
+        throw new ThrottlingError(
+          "RequestLimitExceeded" /* RequestLimitExceeded */,
+          `too many requests ${JSON.stringify(json)}`,
+          { body },
+          "you are making too many requests. please slow down. Reach out to fun team if you need more quota",
+          "https://docs.fun.xyz"
+        );
+      } else if (response.status === 500) {
+        if (json.errorCode === "UserOpFailureError" /* UserOpFailureError */) {
+          throw new UserOpFailureError(
+            "UserOpFailureError" /* UserOpFailureError */,
+            JSON.stringify(json),
+            { body },
+            "fix user op failure. Most of the time this is due to invalid parameters",
+            "https://docs.fun.xyz"
+          );
+        } else {
+          throw new InternalFailureError(
+            "ServerFailure" /* ServerFailure */,
+            `server failure ${JSON.stringify(json)}`,
+            { body },
+            "retry later. if it still fails, please contact us.",
+            "https://docs.fun.xyz"
+          );
+        }
+      } else if (response.status === 504) {
+        throw new InternalFailureError(
+          "ServerTimeout" /* ServerTimeout */,
+          `server timeout failure ${JSON.stringify(json)}`,
+          { body },
+          "retry later. if it still fails, please contact us.",
+          "https://docs.fun.xyz"
+        );
+      } else if (!response.ok) {
+        throw new InternalFailureError(
+          "UnknownServerError" /* UnknownServerError */,
+          `unknown server failure ${JSON.stringify(json)}`,
+          { body },
+          "retry later. if it still fails, please contact us.",
+          "https://docs.fun.xyz"
+        );
+      }
+      return {};
+    }, finalRetryOptions);
+  } catch (err) {
+    throw new InternalFailureError(
+      "ServerConnectionError" /* ServerConnectionError */,
+      `Cannot connect to Fun API Service ${err}`,
+      { body },
+      "retry later. if it still fails, please contact us.",
+      "https://docs.fun.xyz"
+    );
+  }
+};
+async function sendGetRequest({
+  uri,
+  apiKey,
+  retryOptions
+}) {
+  return await sendRequest({
+    uri,
+    apiKey,
+    retryOptions,
+    method: "GET"
+  });
+}
+async function sendPostRequest({
+  uri,
+  body,
+  apiKey,
+  retryOptions
+}) {
+  return await sendRequest({
+    uri,
+    apiKey,
+    body,
+    retryOptions,
+    method: "POST"
+  });
+}
+async function sendDeleteRequest({
+  uri,
+  apiKey,
+  retryOptions
+}) {
+  await sendRequest({
+    uri,
+    method: "DELETE",
+    apiKey,
+    retryOptions
+  });
+}
+async function sendPutRequest({
+  uri,
+  body,
+  apiKey,
+  retryOptions
+}) {
+  return await sendRequest({
+    uri,
+    apiKey,
+    body,
+    retryOptions,
+    method: "PUT"
+  });
+}
+
+// src/services/assets/endpoints.ts
+async function getAssetPriceInfo({
+  chainId,
+  assetTokenAddress,
+  apiKey
+}) {
+  const priceInfo = await sendGetRequest({
+    uri: `${API_BASE_URL}/asset/erc20/price/${chainId}/${assetTokenAddress}`,
+    apiKey,
+    retryOptions: { maxAttempts: 2 }
+  });
+  return priceInfo;
+}
+async function getAllWalletTokens({
+  walletAddress,
+  onlyVerifiedTokens,
+  apiKey
+}) {
+  return await sendGetRequest({
+    uri: `${API_BASE_URL}/assets/erc20s/${walletAddress}?onlyVerifiedTokens=${onlyVerifiedTokens}`,
+    apiKey,
+    retryOptions: { maxAttempts: 2 }
+  });
+}
+async function getAllWalletTokensByChainId({
+  chainId,
+  walletAddress,
+  onlyVerifiedTokens,
+  apiKey
+}) {
+  return await sendGetRequest({
+    uri: `${API_BASE_URL}/assets/erc20s/${walletAddress}/${chainId}?onlyVerifiedTokens=${onlyVerifiedTokens}`,
+    apiKey,
+    retryOptions: { maxAttempts: 2 }
+  });
+}
+async function getAllWalletNFTs({
+  walletAddress,
+  apiKey
+}) {
+  return await sendGetRequest({
+    uri: `${API_BASE_URL}/assets/nfts/${walletAddress}`,
+    apiKey
+  });
+}
+async function getAllWalletNFTsByChainId({
+  chainId,
+  walletAddress,
+  apiKey
+}) {
+  return await sendGetRequest({
+    uri: `${API_BASE_URL}/assets/nfts/${walletAddress}/${chainId}`,
+    apiKey
+  });
+}
+async function getWalletLidoWithdrawalsByChainId({
+  chainId,
+  walletAddress,
+  apiKey
+}) {
+  return await sendGetRequest({
+    uri: `${API_BASE_URL}/assets/lido-withdrawals/${walletAddress}/${chainId}`,
+    apiKey
+  });
+}
+
+// src/services/checkout/endpoints.ts
+import Big from "big.js";
+
+// src/services/checkout/types.ts
+var CheckoutState = /* @__PURE__ */ ((CheckoutState2) => {
+  CheckoutState2["FROM_UNFUNDED"] = "FROM_UNFUNDED";
+  CheckoutState2["FROM_FUNDED"] = "FROM_FUNDED";
+  CheckoutState2["FROM_POOLED"] = "FROM_POOLED";
+  CheckoutState2["TO_UNFUNDED"] = "TO_UNFUNDED";
+  CheckoutState2["TO_FUNDED"] = "TO_FUNDED";
+  CheckoutState2["TO_POOLED"] = "TO_POOLED";
+  CheckoutState2["TO_READY"] = "TO_READY";
+  CheckoutState2["PENDING_RECEIVAL"] = "PENDING_RECEIVAL";
+  CheckoutState2["COMPLETED"] = "COMPLETED";
+  CheckoutState2["CHECKOUT_ERROR"] = "CHECKOUT_ERROR";
+  CheckoutState2["EXPIRED"] = "EXPIRED";
+  CheckoutState2["CANCELLED"] = "CANCELLED";
+  return CheckoutState2;
+})(CheckoutState || {});
+
+// src/services/checkout/endpoints.ts
+async function getCheckoutQuote({
+  fromChainId,
+  fromTokenAddress,
+  fromTokenDecimals,
+  toChainId,
+  toTokenAddress,
+  toTokenDecimals,
+  toTokenAmount,
+  expirationTimestampMs,
+  sponsorInitialTransferGasLimit,
+  recipientAddr,
+  needsRefuel,
+  userId,
+  apiKey
+}) {
+  try {
+    const toMultipler = 10 ** toTokenDecimals;
+    const toAmountBaseUnitBI = BigInt(Math.floor(toTokenAmount * toMultipler));
+    const queryParams = {
+      userId,
+      fromChainId,
+      fromTokenAddress,
+      toChainId,
+      toTokenAddress,
+      toAmountBaseUnit: toAmountBaseUnitBI.toString(),
+      // Only pass in recipientAddr if specified
+      ...recipientAddr ? { recipientAddr } : {},
+      // Rounding nearest tenth second (instead of seconds) to better support backend quote caching feature
+      // Reference: https://vintage-heaven-3cd.notion.site/API-Gateway-Caching-and-Pre-Warming-System-Draft-ee7909d9b85f43c793ce7bd2607bec02?pvs=4
+      // Note: Rounding *down* instead of a regular round to safeguard against edge case of timing passing frontend range validation but failing backend range validation
+      checkoutExpirationTimestampSeconds: roundToNearestBottomTenth(
+        Math.round((Date.now() + expirationTimestampMs) / 1e3)
+      ).toString(),
+      sponsorInitialTransferGasLimit,
+      // @deprecated Not in use
+      refuel: needsRefuel.toString()
+    };
+    const searchParams = new URLSearchParams(queryParams);
+    const quoteRes = await sendGetRequest({
+      uri: `${API_BASE_URL}/checkout/quote?${searchParams}`,
+      apiKey
+    });
+    const fromMultipler = 10 ** fromTokenDecimals;
+    return {
+      quoteId: quoteRes.quoteId,
+      fromTokenAddress: quoteRes.fromTokenAddress,
+      estFeesUsd: quoteRes.estFeesUsd,
+      estSubtotalUsd: quoteRes.estSubtotalUsd,
+      estTotalUsd: quoteRes.estTotalUsd,
+      estCheckoutTimeMs: quoteRes.estCheckoutTimeMs,
+      estTotalFromAmountBaseUnit: quoteRes.estTotalFromAmountBaseUnit,
+      estSubtotalFromAmountBaseUnit: quoteRes.estSubtotalFromAmountBaseUnit,
+      estFeesFromAmountBaseUnit: quoteRes.estFeesFromAmountBaseUnit,
+      // Added fields
+      estFeesFromAmount: new Big(quoteRes.estFeesFromAmountBaseUnit).div(fromMultipler).toString(),
+      estSubtotalFromAmount: new Big(quoteRes.estSubtotalFromAmountBaseUnit).div(fromMultipler).toString(),
+      estTotalFromAmount: new Big(quoteRes.estTotalFromAmountBaseUnit).div(fromMultipler).toString()
+    };
+  } catch (err) {
+    throw new Error(
+      `An error occured trying to generate a checkout quote: ${err.message}`
+    );
+  }
+}
+async function initializeCheckout({
+  userOp,
+  quoteId,
+  sourceOfFund,
+  apiKey,
+  clientMetadata
+}) {
+  const body = {
+    ...userOp ? { userOp } : {},
+    quoteId,
+    sourceOfFund,
+    salt: generateRandomCheckoutSalt(),
+    clientMetadata
+  };
+  const res = await sendPostRequest({
+    uri: `${API_BASE_URL}/checkout`,
+    body,
+    apiKey
+  });
+  if (!res?.depositAddr) {
+    throw new ResourceNotFoundError(
+      "CheckoutInitDepositAddrNotFound" /* CheckoutInitDepositAddrNotFound */,
+      "Unable to initialize checkout",
+      body,
+      "",
+      "https://docs.fun.xyz"
+    );
+  }
+  return res.depositAddr;
+}
+async function deactivateCheckout({
+  depositAddress,
+  apiKey
+}) {
+  try {
+    await sendPostRequest({
+      uri: `${API_BASE_URL}/checkout/update/${depositAddress}`,
+      body: {
+        // Fixed state to cancel the checkout
+        state: "CANCELLED" /* CANCELLED */
+      },
+      apiKey
+    });
+    return true;
+  } catch (err) {
+    throw new Error("Unable to deactivate checkout");
+  }
+}
+async function getCheckoutByDepositAddress({
+  depositAddress,
+  apiKey
+}) {
+  try {
+    return await sendGetRequest({
+      uri: `${API_BASE_URL}/checkout/${depositAddress}`,
+      apiKey
+    });
+  } catch (err) {
+    if (err instanceof ResourceNotFoundError) {
+      return null;
+    }
+    throw err;
+  }
+}
+async function getCheckoutsByFunWalletAddress({
+  funWalletAddress,
+  apiKey
+}) {
+  const res = await sendGetRequest({
+    uri: `${API_BASE_URL}/checkout/fun-wallet/${funWalletAddress}`,
+    apiKey
+  });
+  return res || [];
+}
+async function getCheckoutsByRecipientAddress({
+  recipientAddress,
+  apiKey
+}) {
+  const res = await sendGetRequest({
+    uri: `${API_BASE_URL}/checkout/recipient/${recipientAddress}`,
+    apiKey
+  });
+  return res || [];
+}
+async function getCheckoutsByUserId({
+  userId,
+  apiKey
+}) {
+  const res = await sendGetRequest({
+    uri: `${API_BASE_URL}/checkout/userId/${userId}`,
+    apiKey
+  });
+  return res || [];
+}
+async function getPaymasterDataForCheckoutSponsoredTransfer({
+  depositAddress,
+  transferUserOp,
+  apiKey
+}) {
+  const body = {
+    depositAddress,
+    userOp: transferUserOp
+  };
+  const res = await sendPostRequest({
+    uri: `${API_BASE_URL}/checkout/sponsor-transfer`,
+    body,
+    apiKey
+  });
+  if (!res) {
+    throw new Error("Unable to get sponsorship information");
+  }
+  return res;
+}
+
+// src/services/faucet/endpoints.ts
+async function getAssetFromFaucet({
+  token,
+  chain,
+  walletAddress,
+  apiKey
+}) {
+  return await sendGetRequest({
+    uri: `${FUN_FAUCET_URL}/get-faucet?token=${token}&testnet=${chain}&addr=${walletAddress}`,
+    apiKey
+  });
+}
+
+// src/services/mesh/endpoints.ts
+async function meshGetCryptocurrencyHoldings({
+  authToken,
+  type,
+  apiKey
+}) {
+  const res = await sendPostRequest({
+    uri: `${API_BASE_URL}/mesh/holdings/get`,
+    body: { authToken, type },
+    apiKey
+  });
+  return res;
+}
+async function meshGetTransferIntegrations({
+  apiKey
+}) {
+  const res = await sendGetRequest({
+    uri: `${API_BASE_URL}/mesh/transfers/managed/integrations`,
+    apiKey
+  });
+  return res;
+}
+async function meshGetLinkToken({
+  userId,
+  integrationId,
+  restrictMultipleAccounts,
+  transferOptions,
+  apiKey
+}) {
+  let body = { userId };
+  if (integrationId) {
+    body = { ...body, integrationId };
+  }
+  if (restrictMultipleAccounts) {
+    body = { ...body, restrictMultipleAccounts };
+  }
+  if (transferOptions) {
+    body = { ...body, transferOptions };
+  }
+  const res = await sendPostRequest({
+    uri: `${API_BASE_URL}/mesh/linktoken`,
+    body,
+    apiKey
+  });
+  return res;
+}
+async function meshPreviewTransfer({
+  fromAuthToken,
+  fromType,
+  toAuthToken,
+  toType,
+  networkId,
+  symbol,
+  toAddress,
+  amount,
+  amountInFiat,
+  fiatCurrency,
+  apiKey
+}) {
+  let body = { fromAuthToken, fromType };
+  if (toAuthToken) {
+    body = { ...body, toAuthToken };
+  }
+  if (toType) {
+    body = { ...body, toType };
+  }
+  if (networkId) {
+    body = { ...body, networkId };
+  }
+  if (symbol) {
+    body = { ...body, symbol };
+  }
+  if (toAddress) {
+    body = { ...body, toAddress };
+  }
+  if (amount) {
+    body = { ...body, amount };
+  }
+  if (amountInFiat) {
+    body = { ...body, amountInFiat };
+  }
+  if (fiatCurrency) {
+    body = { ...body, fiatCurrency };
+  }
+  const res = await sendPostRequest({
+    uri: `${API_BASE_URL}/mesh/transfers/managed/preview`,
+    body,
+    apiKey,
+    retryOptions: { maxAttempts: 1 }
+  });
+  return res;
+}
+async function meshExecuteTransfer({
+  fromAuthToken,
+  fromType,
+  previewId,
+  mfaCode,
+  apiKey
+}) {
+  let body = { fromAuthToken, fromType, previewId };
+  if (mfaCode) {
+    body = { ...body, mfaCode };
+  }
+  const res = await sendPostRequest({
+    uri: `${API_BASE_URL}/mesh/transfers/managed/execute`,
+    body,
+    apiKey
+  });
+  return res;
+}
+
+// src/services/mesh/types.ts
+var MeshExecuteTransferStatus = /* @__PURE__ */ ((MeshExecuteTransferStatus2) => {
+  MeshExecuteTransferStatus2["succeeded"] = "succeeded";
+  MeshExecuteTransferStatus2["failed"] = "failed";
+  MeshExecuteTransferStatus2["mfaRequired"] = "mfaRequired";
+  MeshExecuteTransferStatus2["emailConfirmationRequired"] = "emailConfirmationRequired";
+  MeshExecuteTransferStatus2["deviceConfirmationRequired"] = "deviceConfirmationRequired";
+  MeshExecuteTransferStatus2["mfaFailed"] = "mfaFailed";
+  MeshExecuteTransferStatus2["addressWhitelistRequired"] = "addressWhitelistRequired";
+  MeshExecuteTransferStatus2["secondMfaRequired"] = "secondMfaRequired";
+  return MeshExecuteTransferStatus2;
+})(MeshExecuteTransferStatus || {});
+var MeshExecuteTransferMfaType = /* @__PURE__ */ ((MeshExecuteTransferMfaType2) => {
+  MeshExecuteTransferMfaType2["unspecified"] = "unspecified";
+  MeshExecuteTransferMfaType2["phone"] = "phone";
+  MeshExecuteTransferMfaType2["email"] = "email";
+  MeshExecuteTransferMfaType2["otp"] = "otp";
+  return MeshExecuteTransferMfaType2;
+})(MeshExecuteTransferMfaType || {});
+
+// src/services/moonpay/endpoints.ts
+async function getMoonpayUrlSignature({
+  url,
+  isSandbox,
+  apiKey
+}) {
+  const signature = await sendPostRequest({
+    uri: `${API_BASE_URL}/on-ramp/moonpay-signature/`,
+    body: { url, isSandbox },
+    apiKey
+  });
+  if (!signature || !signature?.url) {
+    throw new InternalFailureError(
+      "UnknownServerError" /* UnknownServerError */,
+      "No onramp url found.",
+      { url },
+      "This is an internal error, please contact support.",
+      "https://docs.fun.xyz"
+    );
+  }
+  return signature.url;
+}
+async function getMoonpayBuyQuoteForCreditCard({
+  currencyCode,
+  baseCurrencyCode,
+  quoteCurrencyAmount,
+  baseCurrencyAmount,
+  extraFeePercentage,
+  areFeesIncluded,
+  apiKey
+}) {
+  const params = new URLSearchParams({
+    currencyCode,
+    baseCurrencyCode,
+    quoteCurrencyAmount,
+    paymentMethod: "credit_debit_card",
+    ...baseCurrencyAmount == null ? {} : { baseCurrencyAmount: baseCurrencyAmount.toString() },
+    ...extraFeePercentage == null ? {} : { extraFeePercentage: extraFeePercentage.toString() },
+    ...areFeesIncluded == null ? {} : { areFeesIncluded: areFeesIncluded.toString() }
+  }).toString();
+  const res = await sendGetRequest({
+    uri: `${API_BASE_URL}/on-ramp/moonpay-buy-quote?${params}`,
+    apiKey,
+    retryOptions: { maxAttempts: 1 }
+  });
+  return res;
+}
+async function getMoonpayOnRampUrl({
+  apiKey,
+  walletAddr,
+  currencyCode
+}) {
+  const endpoint = `on-ramp/${walletAddr}?provider=moonpay`;
+  if (currencyCode) {
+    endpoint.concat(`&currencyCode=${currencyCode}`);
+  }
+  const url = (await sendGetRequest({
+    uri: `${API_BASE_URL}/${endpoint}`,
+    apiKey
+  }))?.url;
+  if (!url) {
+    throw new InternalFailureError(
+      "UnknownServerError" /* UnknownServerError */,
+      "No onramp url found.",
+      { walletAddr },
+      "This is an internal error, please contact support.",
+      "https://docs.fun.xyz"
+    );
+  }
+  return url;
+}
+async function getMoonpayOffRampUrl({
+  walletAddr,
+  apiKey
+}) {
+  const url = (await sendGetRequest({
+    uri: `${API_BASE_URL}/off-ramp/${walletAddr}?provider=moonpay`,
+    apiKey
+  }))?.url;
+  if (!url) {
+    throw new InternalFailureError(
+      "UnknownServerError" /* UnknownServerError */,
+      "No offramp url found.",
+      { walletAddr },
+      "This is an internal error, please contact support.",
+      "https://docs.fun.xyz"
+    );
+  }
+  return url;
+}
+async function getMoonpayOnRampSupportedCurrencies({
+  apiKey
+}) {
+  const currencies = await sendGetRequest({
+    uri: `${API_BASE_URL}/on-ramp/moonpay-currencies`,
+    apiKey
+  });
+  if (!currencies || !currencies.length) {
+    throw new InternalFailureError(
+      "UnknownServerError" /* UnknownServerError */,
+      "No supported currencies found.",
+      {},
+      "This is an internal error, please contact support.",
+      "https://docs.fun.xyz"
+    );
+  }
+  return currencies;
+}
+
+// src/services/stripe/endpoints.ts
+async function getStripeBuyQuote({
+  sourceCurrency,
+  destinationAmount,
+  destinationCurrency,
+  destinationNetwork,
+  isSandbox,
+  apiKey
+}) {
+  const params = new URLSearchParams({
+    isSandbox: isSandbox.toString(),
+    sourceCurrency,
+    destinationAmount: destinationAmount.toString(),
+    // Only allow one currency in this SDK
+    destinationCurrencies: destinationCurrency,
+    // Only allow one network in this SDK
+    destinationNetworks: destinationNetwork
+  }).toString();
+  const buyQuoteResp = await sendGetRequest({
+    uri: `${API_BASE_URL}/on-ramp/stripe-buy-quote?${params}`,
+    retryOptions: { maxAttempts: 1 },
+    apiKey
+  });
+  return buyQuoteResp;
+}
+async function createStripeBuySession({
+  sourceCurrency,
+  destinationAmount,
+  destinationCurrency,
+  destinationNetwork,
+  walletAddress,
+  customerIpAddress,
+  isSandbox,
+  apiKey
+}) {
+  const body = {
+    isSandbox: isSandbox.toString(),
+    sourceCurrency,
+    destinationAmount: destinationAmount.toString(),
+    // Only allow one currency in this SDK
+    destinationCurrency,
+    destinationCurrencies: [destinationCurrency],
+    // Only allow one network in this SDK
+    destinationNetwork,
+    destinationNetworks: [destinationNetwork],
+    // Only allow one wallet address in this SDK, and it must correspond to the destination network
+    walletAddresses: {
+      [destinationNetwork]: walletAddress
+    },
+    ...customerIpAddress ? { customerIpAddress } : {}
+  };
+  const newBuySessionResp = await sendPostRequest({
+    uri: `${API_BASE_URL}/on-ramp/stripe-checkout`,
+    body,
+    retryOptions: { maxAttempts: 1 },
+    apiKey
+  });
+  return newBuySessionResp;
+}
+async function getStripeBuySession({
+  sessionId,
+  apiKey
+}) {
+  const buySessionResp = await sendGetRequest({
+    uri: `${API_BASE_URL}/on-ramp/stripe-checkout-session/${sessionId}`,
+    retryOptions: { maxAttempts: 1 },
+    apiKey
+  });
+  return buySessionResp;
+}
+
+// src/services/support/endpoints.ts
+async function sendSupportMessage({
+  title,
+  description,
+  userEmail,
+  apiKey
+}) {
+  try {
+    await sendPostRequest({
+      uri: `${API_BASE_URL}/support/send-message`,
+      body: { title, description, userEmail },
+      apiKey,
+      retryOptions: { maxAttempts: 1 }
+    });
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+// src/services/turnkey/endpoints.ts
+async function createTurnkeySubOrg({
+  createSubOrgRequest,
+  apiKey
+}) {
+  const res = await sendPostRequest({
+    uri: `${API_BASE_URL}/turnkey/sub-org`,
+    body: createSubOrgRequest,
+    apiKey
+  });
+  return res;
+}
+async function createTurnkeyPrivateKey({
+  signedRequest,
+  apiKey
+}) {
+  const res = await sendPostRequest({
+    uri: `${API_BASE_URL}/turnkey/private-key`,
+    body: signedRequest,
+    apiKey
+  });
+  return {
+    id: res.id,
+    address: res.address
+  };
+}
+export {
+  API_BASE_URL,
+  AccessDeniedError,
+  BaseError,
+  CheckoutState,
+  ClientError,
+  DEFAULT_RETRY_OPTIONS,
+  ErrorBaseType,
+  ErrorCode,
+  ErrorType,
+  FUN_FAUCET_URL,
+  InternalFailureError,
+  InvalidActionError,
+  InvalidParameterError,
+  MeshExecuteTransferMfaType,
+  MeshExecuteTransferStatus,
+  ResourceNotFoundError,
+  ServerError,
+  ThrottlingError,
+  UserOpFailureError,
+  createStripeBuySession,
+  createTurnkeyPrivateKey,
+  createTurnkeySubOrg,
+  deactivateCheckout,
+  errorAbortHandler,
+  generateRandomCheckoutSalt,
+  getAllWalletNFTs,
+  getAllWalletNFTsByChainId,
+  getAllWalletTokens,
+  getAllWalletTokensByChainId,
+  getAssetFromFaucet,
+  getAssetPriceInfo,
+  getCheckoutByDepositAddress,
+  getCheckoutQuote,
+  getCheckoutsByFunWalletAddress,
+  getCheckoutsByRecipientAddress,
+  getCheckoutsByUserId,
+  getMoonpayBuyQuoteForCreditCard,
+  getMoonpayOffRampUrl,
+  getMoonpayOnRampSupportedCurrencies,
+  getMoonpayOnRampUrl,
+  getMoonpayUrlSignature,
+  getPaymasterDataForCheckoutSponsoredTransfer,
+  getStripeBuyQuote,
+  getStripeBuySession,
+  getWalletLidoWithdrawalsByChainId,
+  initializeCheckout,
+  meshExecuteTransfer,
+  meshGetCryptocurrencyHoldings,
+  meshGetLinkToken,
+  meshGetTransferIntegrations,
+  meshPreviewTransfer,
+  randomBytes,
+  roundToNearestBottomTenth,
+  sendDeleteRequest,
+  sendGetRequest,
+  sendPostRequest,
+  sendPutRequest,
+  sendRequest,
+  sendSupportMessage
+};
+//# sourceMappingURL=index.js.map