@vetro-protocol/gateway 1.3.0 → 1.3.1

package/_esm/chunk-ZE4YZMXK.js

@@ -0,0 +1,1326 @@
+// ../core/src/stakingVaultAddresses.ts
+var sVusdAddress = "0x476310E34D2810f7d79C43A74E4D79405bd7a925";
+var sVetBtcAddress = "0x0cB9D84d4bcEc8d3D5B2d99a6F07f4605325987e";
+
+// ../core/src/protocolGraph.ts
+var gateways = [
+  {
+    // VUSD gateway
+    address: "0xDaD503f8B9d42bb7af3AfC588358D30163e4416F",
+    pegBaseSymbol: "USD",
+    // VUSD
+    peggedToken: "0xCa83DDE9c22254f58e771bE5E157773212AcBAc3",
+    stakingVault: sVusdAddress,
+    treasury: "0xC8317A10385BE07901A4c9ee3d06E1D83AE378c9",
+    whitelistedTokens: [
+      // USDT
+      "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+      // USDC
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+      // frxUSD
+      "0xCAcd6fd266aF91b8AeD52aCCc382b4e165586E29"
+    ]
+  },
+  {
+    // vetBTC gateway
+    address: "0xCBA2Ffa0AC52d7871a4221a871793Eb788013faB",
+    pegBaseSymbol: "BTC",
+    // vetBTC
+    peggedToken: "0xf196C68233464A16CFDa319a47c21f4cECa62001",
+    stakingVault: sVetBtcAddress,
+    treasury: "0xd25a7b0b817fD816d0995eC67fb70e75EE65Bd7F",
+    whitelistedTokens: [
+      // WBTC
+      "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
+      // cbBTC
+      "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf",
+      // hemiBTC
+      "0x06ea695B91700071B161A434fED42D1DcbAD9f00"
+    ]
+  }
+];
+var gatewayAddresses = gateways.map(
+  (gateway) => gateway.address
+);
+
+// ../core/src/utils/isAddressValid.ts
+import { isAddress, isAddressEqual, zeroAddress } from "viem";
+var isAddressValid = (address) => !!address && isAddress(address) && !isAddressEqual(address, zeroAddress);
+
+// src/actions/public/getGateway.ts
+import { readContract } from "viem/actions";
+
+// src/abi/peggedTokenAbi.ts
+var peggedTokenAbi = [
+  {
+    inputs: [],
+    name: "gateway",
+    outputs: [{ type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+
+// src/actions/public/getGateway.ts
+async function getGateway(client, parameters) {
+  if (!client) {
+    throw new Error("Client is not defined");
+  }
+  if (!parameters) {
+    throw new Error("Parameters are required");
+  }
+  if (!isAddressValid(parameters.address)) {
+    throw new Error("Pegged token is invalid");
+  }
+  return readContract(client, {
+    abi: peggedTokenAbi,
+    address: parameters.address,
+    functionName: "gateway"
+  });
+}
+
+// src/abi/gatewayAbi.ts
+var gatewayAbi = [
+  {
+    inputs: [],
+    name: "PEGGED_TOKEN",
+    outputs: [{ type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "token_", type: "address" }],
+    name: "mintFee",
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "mintLimit",
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "owner",
+    outputs: [{ type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "token_", type: "address" }],
+    name: "redeemFee",
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "treasury",
+    outputs: [{ type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "withdrawalDelayEnabled",
+    outputs: [{ type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "withdrawalDelay",
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "user_", type: "address" }],
+    name: "getRedeemRequest",
+    outputs: [
+      { name: "amountLocked", type: "uint256" },
+      { name: "claimableAt", type: "uint256" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "account_", type: "address" }],
+    name: "isInstantRedeemWhitelisted",
+    outputs: [{ type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "maxMint",
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "tokenOut_", type: "address" }],
+    name: "maxWithdraw",
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "account_", type: "address" }],
+    name: "addToInstantRedeemWhitelist",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "account_", type: "address" }],
+    name: "removeFromInstantRedeemWhitelist",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "tokenIn_", type: "address" },
+      { name: "amountIn_", type: "uint256" }
+    ],
+    name: "previewDeposit",
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "tokenOut_", type: "address" },
+      { name: "peggedTokenIn_", type: "uint256" }
+    ],
+    name: "previewRedeem",
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "tokenOut_", type: "address" },
+      { name: "amountOut_", type: "uint256" }
+    ],
+    name: "previewWithdraw",
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "cancelRedeemRequest",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "tokenIn_", type: "address" },
+      { name: "amountIn_", type: "uint256" },
+      { name: "minPeggedTokenOut_", type: "uint256" },
+      { name: "receiver_", type: "address" }
+    ],
+    name: "deposit",
+    outputs: [{ type: "uint256" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "tokenOut_", type: "address" },
+      { name: "peggedTokenIn_", type: "uint256" },
+      { name: "minAmountOut_", type: "uint256" },
+      { name: "receiver_", type: "address" }
+    ],
+    name: "redeem",
+    outputs: [{ type: "uint256" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "peggedTokenAmount_", type: "uint256" }],
+    name: "requestRedeem",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "enabled_", type: "bool" }],
+    name: "setWithdrawalDelayEnabled",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "token_", type: "address" },
+      { name: "newMintFee_", type: "uint256" }
+    ],
+    name: "updateMintFee",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "newMintLimit_", type: "uint256" }],
+    name: "updateMintLimit",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "token_", type: "address" },
+      { name: "newRedeemFee_", type: "uint256" }
+    ],
+    name: "updateRedeemFee",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "newDelay_", type: "uint256" }],
+    name: "updateWithdrawalDelay",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "user", type: "address" },
+      { indexed: false, name: "amount", type: "uint256" },
+      { indexed: false, name: "claimableAt", type: "uint256" }
+    ],
+    name: "RedeemRequested",
+    type: "event"
+  }
+];
+
+// src/actions/public/getMaxMint.ts
+import { readContract as readContract2 } from "viem/actions";
+async function getMaxMint(client, parameters) {
+  if (!client) {
+    throw new Error("Client is not defined");
+  }
+  if (!parameters) {
+    throw new Error("Parameters are required");
+  }
+  if (!isAddressValid(parameters.address)) {
+    throw new Error("Gateway is invalid");
+  }
+  return readContract2(client, {
+    abi: gatewayAbi,
+    address: parameters.address,
+    functionName: "maxMint"
+  });
+}
+
+// src/actions/public/getMaxWithdraw.ts
+import { readContract as readContract3 } from "viem/actions";
+async function getMaxWithdraw(client, parameters) {
+  if (!client) {
+    throw new Error("Client is not defined");
+  }
+  if (!parameters) {
+    throw new Error("Parameters are required");
+  }
+  if (!isAddressValid(parameters.address)) {
+    throw new Error("Gateway is invalid");
+  }
+  if (!isAddressValid(parameters.tokenOut)) {
+    throw new Error("Token is invalid");
+  }
+  return readContract3(client, {
+    abi: gatewayAbi,
+    address: parameters.address,
+    args: [parameters.tokenOut],
+    functionName: "maxWithdraw"
+  });
+}
+
+// src/actions/public/getMintFee.ts
+import { readContract as readContract4 } from "viem/actions";
+async function getMintFee(client, parameters) {
+  if (!client) {
+    throw new Error("Client is not defined");
+  }
+  if (!parameters) {
+    throw new Error("Parameters are required");
+  }
+  if (!isAddressValid(parameters.address)) {
+    throw new Error("Gateway is invalid");
+  }
+  if (!isAddressValid(parameters.token)) {
+    throw new Error("Token is invalid");
+  }
+  return readContract4(client, {
+    abi: gatewayAbi,
+    address: parameters.address,
+    args: [parameters.token],
+    functionName: "mintFee"
+  });
+}
+
+// src/actions/public/getPeggedToken.ts
+import { readContract as readContract5 } from "viem/actions";
+async function getPeggedToken(client, parameters) {
+  if (!client) {
+    throw new Error("Client is not defined");
+  }
+  if (!parameters) {
+    throw new Error("Parameters are required");
+  }
+  if (!isAddressValid(parameters.address)) {
+    throw new Error("Gateway is invalid");
+  }
+  return readContract5(client, {
+    abi: gatewayAbi,
+    address: parameters.address,
+    functionName: "PEGGED_TOKEN"
+  });
+}
+
+// src/actions/public/getRedeemFee.ts
+import { readContract as readContract6 } from "viem/actions";
+async function getRedeemFee(client, parameters) {
+  if (!client) {
+    throw new Error("Client is not defined");
+  }
+  if (!parameters) {
+    throw new Error("Parameters are required");
+  }
+  if (!isAddressValid(parameters.address)) {
+    throw new Error("Gateway is invalid");
+  }
+  if (!isAddressValid(parameters.token)) {
+    throw new Error("Token is invalid");
+  }
+  return readContract6(client, {
+    abi: gatewayAbi,
+    address: parameters.address,
+    args: [parameters.token],
+    functionName: "redeemFee"
+  });
+}
+
+// src/actions/public/getRedeemRequest.ts
+import { readContract as readContract7 } from "viem/actions";
+async function getRedeemRequest(client, parameters) {
+  if (!client) {
+    throw new Error("Client is not defined");
+  }
+  if (!parameters) {
+    throw new Error("Parameters are required");
+  }
+  if (!isAddressValid(parameters.address)) {
+    throw new Error("Gateway is invalid");
+  }
+  if (!isAddressValid(parameters.user)) {
+    throw new Error("User is invalid");
+  }
+  return readContract7(client, {
+    abi: gatewayAbi,
+    address: parameters.address,
+    args: [parameters.user],
+    functionName: "getRedeemRequest"
+  });
+}
+
+// src/actions/public/getTreasury.ts
+import { readContract as readContract8 } from "viem/actions";
+async function getTreasury(client, parameters) {
+  if (!client) {
+    throw new Error("Client is not defined");
+  }
+  if (!parameters) {
+    throw new Error("Parameters are required");
+  }
+  if (!isAddressValid(parameters.address)) {
+    throw new Error("Gateway is invalid");
+  }
+  return readContract8(client, {
+    abi: gatewayAbi,
+    address: parameters.address,
+    functionName: "treasury"
+  });
+}
+
+// src/actions/public/getWithdrawalDelay.ts
+import { readContract as readContract9 } from "viem/actions";
+async function getWithdrawalDelay(client, parameters) {
+  if (!client) {
+    throw new Error("Client is not defined");
+  }
+  if (!parameters) {
+    throw new Error("Parameters are required");
+  }
+  if (!isAddressValid(parameters.address)) {
+    throw new Error("Gateway is invalid");
+  }
+  return readContract9(client, {
+    abi: gatewayAbi,
+    address: parameters.address,
+    functionName: "withdrawalDelay"
+  });
+}
+
+// src/actions/public/getWithdrawalDelayEnabled.ts
+import { readContract as readContract10 } from "viem/actions";
+async function getWithdrawalDelayEnabled(client, parameters) {
+  if (!client) {
+    throw new Error("Client is not defined");
+  }
+  if (!parameters) {
+    throw new Error("Parameters are required");
+  }
+  if (!isAddressValid(parameters.address)) {
+    throw new Error("Gateway is invalid");
+  }
+  return readContract10(client, {
+    abi: gatewayAbi,
+    address: parameters.address,
+    functionName: "withdrawalDelayEnabled"
+  });
+}
+
+// src/actions/public/isInstantRedeemWhitelisted.ts
+import { readContract as readContract11 } from "viem/actions";
+async function isInstantRedeemWhitelisted(client, parameters) {
+  if (!client) {
+    throw new Error("Client is not defined");
+  }
+  if (!parameters) {
+    throw new Error("Parameters are required");
+  }
+  if (!isAddressValid(parameters.address)) {
+    throw new Error("Gateway is invalid");
+  }
+  if (!isAddressValid(parameters.account)) {
+    throw new Error("Account is invalid");
+  }
+  return readContract11(client, {
+    abi: gatewayAbi,
+    address: parameters.address,
+    args: [parameters.account],
+    functionName: "isInstantRedeemWhitelisted"
+  });
+}
+
+// src/actions/public/previewDeposit.ts
+import { readContract as readContract12 } from "viem/actions";
+async function previewDeposit(client, parameters) {
+  if (!client) {
+    throw new Error("Client is not defined");
+  }
+  if (!parameters) {
+    throw new Error("Parameters are required");
+  }
+  if (!isAddressValid(parameters.address)) {
+    throw new Error("Gateway is invalid");
+  }
+  if (!isAddressValid(parameters.tokenIn)) {
+    throw new Error("Token is invalid");
+  }
+  if (typeof parameters.amountIn !== "bigint") {
+    throw new Error("Amount must be a bigint");
+  }
+  if (parameters.amountIn <= 0n) {
+    throw new Error("Amount must be greater than 0");
+  }
+  return readContract12(client, {
+    abi: gatewayAbi,
+    address: parameters.address,
+    args: [parameters.tokenIn, parameters.amountIn],
+    functionName: "previewDeposit"
+  });
+}
+
+// src/actions/public/previewRedeem.ts
+import { readContract as readContract13 } from "viem/actions";
+async function previewRedeem(client, parameters) {
+  if (!client) {
+    throw new Error("Client is not defined");
+  }
+  if (!parameters) {
+    throw new Error("Parameters are required");
+  }
+  if (!isAddressValid(parameters.address)) {
+    throw new Error("Gateway is invalid");
+  }
+  if (!isAddressValid(parameters.tokenOut)) {
+    throw new Error("Token is invalid");
+  }
+  if (typeof parameters.peggedTokenIn !== "bigint") {
+    throw new Error("Amount must be a bigint");
+  }
+  if (parameters.peggedTokenIn <= 0n) {
+    throw new Error("Amount must be greater than 0");
+  }
+  return readContract13(client, {
+    abi: gatewayAbi,
+    address: parameters.address,
+    args: [parameters.tokenOut, parameters.peggedTokenIn],
+    functionName: "previewRedeem"
+  });
+}
+
+// src/actions/public/previewWithdraw.ts
+import { readContract as readContract14 } from "viem/actions";
+async function previewWithdraw(client, parameters) {
+  if (!client) {
+    throw new Error("Client is not defined");
+  }
+  if (!parameters) {
+    throw new Error("Parameters are required");
+  }
+  if (!isAddressValid(parameters.address)) {
+    throw new Error("Gateway is invalid");
+  }
+  if (!isAddressValid(parameters.tokenOut)) {
+    throw new Error("Token is invalid");
+  }
+  if (typeof parameters.amountOut !== "bigint") {
+    throw new Error("Amount must be a bigint");
+  }
+  if (parameters.amountOut <= 0n) {
+    throw new Error("Amount must be greater than 0");
+  }
+  return readContract14(client, {
+    abi: gatewayAbi,
+    address: parameters.address,
+    args: [parameters.tokenOut, parameters.amountOut],
+    functionName: "previewWithdraw"
+  });
+}
+
+// src/actions/wallet/cancelRedeemRequest.ts
+import { toPromiseEvent } from "to-promise-event";
+import {
+  encodeFunctionData,
+  isAddress as isAddress2,
+  isAddressEqual as isAddressEqual2,
+  zeroAddress as zeroAddress2
+} from "viem";
+import { waitForTransactionReceipt, writeContract } from "viem/actions";
+var canCancelRedeemRequest = function({
+  client,
+  gatewayAddress
+}) {
+  if (!client) {
+    return {
+      canCancelRedeemRequest: false,
+      reason: "Client is not defined"
+    };
+  }
+  if (!client.chain) {
+    return {
+      canCancelRedeemRequest: false,
+      reason: "Chain is not defined on wallet client"
+    };
+  }
+  if (!client.account) {
+    return {
+      canCancelRedeemRequest: false,
+      reason: "Client must have an account"
+    };
+  }
+  if (!gatewayAddress || !isAddress2(gatewayAddress)) {
+    return {
+      canCancelRedeemRequest: false,
+      reason: "Invalid gateway address"
+    };
+  }
+  if (isAddressEqual2(gatewayAddress, zeroAddress2)) {
+    return {
+      canCancelRedeemRequest: false,
+      reason: "Gateway address cannot be zero address"
+    };
+  }
+  return { canCancelRedeemRequest: true };
+};
+var runCancelRedeemRequest = (walletClient, { gatewayAddress }) => async function(emitter) {
+  try {
+    const { canCancelRedeemRequest: canCancelRedeemRequestFlag, reason } = canCancelRedeemRequest({
+      client: walletClient,
+      gatewayAddress
+    });
+    if (!canCancelRedeemRequestFlag) {
+      emitter.emit("cancel-redeem-request-failed-validation", reason);
+      return;
+    }
+    emitter.emit("pre-cancel-redeem-request");
+    const cancelHash = await writeContract(walletClient, {
+      abi: gatewayAbi,
+      account: walletClient.account,
+      address: gatewayAddress,
+      chain: walletClient.chain,
+      functionName: "cancelRedeemRequest"
+    }).catch(function(error) {
+      emitter.emit("user-signing-cancel-redeem-request-error", error);
+    });
+    if (!cancelHash) {
+      return;
+    }
+    emitter.emit("user-signed-cancel-redeem-request", cancelHash);
+    const cancelReceipt = await waitForTransactionReceipt(walletClient, {
+      hash: cancelHash
+    }).catch(function(error) {
+      emitter.emit("cancel-redeem-request-failed", error);
+    });
+    if (!cancelReceipt) {
+      return;
+    }
+    const cancelEventMap = {
+      reverted: "cancel-redeem-request-transaction-reverted",
+      success: "cancel-redeem-request-transaction-succeeded"
+    };
+    emitter.emit(cancelEventMap[cancelReceipt.status], cancelReceipt);
+  } catch (error) {
+    emitter.emit("unexpected-error", error);
+  } finally {
+    emitter.emit("cancel-redeem-request-settled");
+  }
+};
+var cancelRedeemRequest = (...args) => toPromiseEvent(runCancelRedeemRequest(...args));
+var encodeCancelRedeemRequest = () => encodeFunctionData({
+  abi: gatewayAbi,
+  functionName: "cancelRedeemRequest"
+});
+
+// src/actions/wallet/deposit.ts
+import { toPromiseEvent as toPromiseEvent2 } from "to-promise-event";
+import {
+  encodeFunctionData as encodeFunctionData2,
+  isAddress as isAddress3,
+  isAddressEqual as isAddressEqual3,
+  zeroAddress as zeroAddress3
+} from "viem";
+import { waitForTransactionReceipt as waitForTransactionReceipt2, writeContract as writeContract2 } from "viem/actions";
+import { allowance, approve } from "viem-erc20/actions";
+var canDeposit = function({
+  amountIn,
+  approveAmount,
+  client,
+  gatewayAddress,
+  minPeggedTokenOut,
+  receiver,
+  tokenIn
+}) {
+  if (!client) {
+    return {
+      canDeposit: false,
+      reason: "Client is not defined"
+    };
+  }
+  if (!client.chain) {
+    return {
+      canDeposit: false,
+      reason: "Chain is not defined on wallet client"
+    };
+  }
+  if (!client.account) {
+    return {
+      canDeposit: false,
+      reason: "Client must have an account"
+    };
+  }
+  if (!gatewayAddress || !isAddress3(gatewayAddress)) {
+    return {
+      canDeposit: false,
+      reason: "Invalid gateway address"
+    };
+  }
+  if (isAddressEqual3(gatewayAddress, zeroAddress3)) {
+    return {
+      canDeposit: false,
+      reason: "Gateway address cannot be zero address"
+    };
+  }
+  if (!tokenIn || !isAddress3(tokenIn)) {
+    return {
+      canDeposit: false,
+      reason: "Invalid token address"
+    };
+  }
+  if (isAddressEqual3(tokenIn, zeroAddress3)) {
+    return {
+      canDeposit: false,
+      reason: "Token address cannot be zero address"
+    };
+  }
+  if (!receiver || !isAddress3(receiver)) {
+    return {
+      canDeposit: false,
+      reason: "Invalid receiver address"
+    };
+  }
+  if (isAddressEqual3(receiver, zeroAddress3)) {
+    return {
+      canDeposit: false,
+      reason: "Receiver address cannot be zero address"
+    };
+  }
+  if (typeof amountIn !== "bigint") {
+    return {
+      canDeposit: false,
+      reason: "Amount must be a bigint"
+    };
+  }
+  if (amountIn <= 0n) {
+    return {
+      canDeposit: false,
+      reason: "Amount must be greater than 0"
+    };
+  }
+  if (typeof minPeggedTokenOut !== "bigint") {
+    return {
+      canDeposit: false,
+      reason: "Minimum output must be a bigint"
+    };
+  }
+  if (minPeggedTokenOut < 0n) {
+    return {
+      canDeposit: false,
+      reason: "Minimum output cannot be negative"
+    };
+  }
+  if (approveAmount < amountIn) {
+    return {
+      canDeposit: false,
+      reason: "Approve amount must be greater than or equal to amount"
+    };
+  }
+  return { canDeposit: true };
+};
+var runDeposit = (walletClient, {
+  amountIn,
+  approveAmount = amountIn,
+  gatewayAddress,
+  minPeggedTokenOut,
+  receiver,
+  tokenIn
+}) => async function(emitter) {
+  try {
+    const { canDeposit: canDepositFlag, reason } = canDeposit({
+      amountIn,
+      approveAmount,
+      client: walletClient,
+      gatewayAddress,
+      minPeggedTokenOut,
+      receiver,
+      tokenIn
+    });
+    if (!canDepositFlag) {
+      emitter.emit("deposit-failed-validation", reason);
+      return;
+    }
+    const currentAllowance = await allowance(walletClient, {
+      address: tokenIn,
+      // account is already validated
+      owner: walletClient.account.address,
+      spender: gatewayAddress
+    });
+    if (currentAllowance < amountIn) {
+      emitter.emit("pre-approve");
+      const approvalHash = await approve(walletClient, {
+        address: tokenIn,
+        amount: approveAmount,
+        spender: gatewayAddress
+      }).catch(function(error) {
+        emitter.emit("user-signing-approval-error", error);
+      });
+      if (!approvalHash) {
+        return;
+      }
+      emitter.emit("user-signed-approval", approvalHash);
+      const approvalReceipt = await waitForTransactionReceipt2(walletClient, {
+        hash: approvalHash
+      }).catch(function(error) {
+        emitter.emit("deposit-failed", error);
+      });
+      if (!approvalReceipt) {
+        return;
+      }
+      if (approvalReceipt.status === "reverted") {
+        emitter.emit("approve-transaction-reverted", approvalReceipt);
+        return;
+      }
+      emitter.emit("approve-transaction-succeeded", approvalReceipt);
+    }
+    emitter.emit("pre-deposit");
+    const depositHash = await writeContract2(walletClient, {
+      abi: gatewayAbi,
+      account: walletClient.account,
+      address: gatewayAddress,
+      args: [tokenIn, amountIn, minPeggedTokenOut, receiver],
+      chain: walletClient.chain,
+      functionName: "deposit"
+    }).catch(function(error) {
+      emitter.emit("user-signing-deposit-error", error);
+    });
+    if (!depositHash) {
+      return;
+    }
+    emitter.emit("user-signed-deposit", depositHash);
+    const depositReceipt = await waitForTransactionReceipt2(walletClient, {
+      hash: depositHash
+    }).catch(function(error) {
+      emitter.emit("deposit-failed", error);
+    });
+    if (!depositReceipt) {
+      return;
+    }
+    const depositEventMap = {
+      reverted: "deposit-transaction-reverted",
+      success: "deposit-transaction-succeeded"
+    };
+    emitter.emit(depositEventMap[depositReceipt.status], depositReceipt);
+  } catch (error) {
+    emitter.emit("unexpected-error", error);
+  } finally {
+    emitter.emit("deposit-settled");
+  }
+};
+var deposit = (...args) => toPromiseEvent2(runDeposit(...args));
+var encodeDeposit = ({
+  amountIn,
+  minPeggedTokenOut,
+  receiver,
+  tokenIn
+}) => encodeFunctionData2({
+  abi: gatewayAbi,
+  args: [tokenIn, amountIn, minPeggedTokenOut, receiver],
+  functionName: "deposit"
+});
+
+// src/actions/wallet/redeem.ts
+import { toPromiseEvent as toPromiseEvent3 } from "to-promise-event";
+import {
+  encodeFunctionData as encodeFunctionData3,
+  isAddress as isAddress4,
+  isAddressEqual as isAddressEqual4,
+  zeroAddress as zeroAddress4
+} from "viem";
+import { waitForTransactionReceipt as waitForTransactionReceipt3, writeContract as writeContract3 } from "viem/actions";
+import { allowance as allowance2, approve as approve2 } from "viem-erc20/actions";
+var canRedeem = async function({
+  approveAmount,
+  client,
+  gatewayAddress,
+  minAmountOut,
+  peggedTokenIn,
+  receiver,
+  tokenOut
+}) {
+  if (!client) {
+    return {
+      canRedeem: false,
+      reason: "Client is not defined"
+    };
+  }
+  if (!client.chain) {
+    return {
+      canRedeem: false,
+      reason: "Chain is not defined on wallet client"
+    };
+  }
+  if (!client.account) {
+    return {
+      canRedeem: false,
+      reason: "Client must have an account"
+    };
+  }
+  if (!gatewayAddress || !isAddress4(gatewayAddress)) {
+    return {
+      canRedeem: false,
+      reason: "Invalid gateway address"
+    };
+  }
+  if (isAddressEqual4(gatewayAddress, zeroAddress4)) {
+    return {
+      canRedeem: false,
+      reason: "Gateway address cannot be zero address"
+    };
+  }
+  if (!tokenOut || !isAddress4(tokenOut)) {
+    return {
+      canRedeem: false,
+      reason: "Invalid token address"
+    };
+  }
+  if (isAddressEqual4(tokenOut, zeroAddress4)) {
+    return {
+      canRedeem: false,
+      reason: "Token address cannot be zero address"
+    };
+  }
+  if (!receiver || !isAddress4(receiver)) {
+    return {
+      canRedeem: false,
+      reason: "Invalid receiver address"
+    };
+  }
+  if (isAddressEqual4(receiver, zeroAddress4)) {
+    return {
+      canRedeem: false,
+      reason: "Receiver address cannot be zero address"
+    };
+  }
+  if (typeof peggedTokenIn !== "bigint") {
+    return {
+      canRedeem: false,
+      reason: "Amount must be a bigint"
+    };
+  }
+  if (peggedTokenIn <= 0n) {
+    return {
+      canRedeem: false,
+      reason: "Amount must be greater than 0"
+    };
+  }
+  if (typeof minAmountOut !== "bigint") {
+    return {
+      canRedeem: false,
+      reason: "Minimum output must be a bigint"
+    };
+  }
+  if (minAmountOut < 0n) {
+    return {
+      canRedeem: false,
+      reason: "Minimum output cannot be negative"
+    };
+  }
+  if (approveAmount < peggedTokenIn) {
+    return {
+      canRedeem: false,
+      reason: "Approve amount must be greater than or equal to amount"
+    };
+  }
+  const maxWithdrawable = await getMaxWithdraw(client, {
+    address: gatewayAddress,
+    tokenOut
+  });
+  if (minAmountOut > maxWithdrawable) {
+    return {
+      canRedeem: false,
+      reason: "Not enough balance in treasury"
+    };
+  }
+  return { canRedeem: true };
+};
+var runRedeem = (walletClient, {
+  approveAmount,
+  gatewayAddress,
+  minAmountOut,
+  peggedTokenIn,
+  receiver,
+  tokenOut
+}) => async function(emitter) {
+  const resolvedApproveAmount = approveAmount ?? peggedTokenIn;
+  try {
+    const { canRedeem: canRedeemFlag, reason } = await canRedeem({
+      approveAmount: resolvedApproveAmount,
+      client: walletClient,
+      gatewayAddress,
+      minAmountOut,
+      peggedTokenIn,
+      receiver,
+      tokenOut
+    });
+    if (!canRedeemFlag) {
+      emitter.emit("redeem-failed-validation", reason);
+      return;
+    }
+    const [isWhitelisted, delayEnabled] = await Promise.all([
+      isInstantRedeemWhitelisted(walletClient, {
+        account: walletClient.account.address,
+        address: gatewayAddress
+      }),
+      getWithdrawalDelayEnabled(walletClient, {
+        address: gatewayAddress
+      })
+    ]);
+    if (isWhitelisted || !delayEnabled) {
+      const peggedTokenAddress = await getPeggedToken(walletClient, {
+        address: gatewayAddress
+      });
+      const currentAllowance = await allowance2(walletClient, {
+        address: peggedTokenAddress,
+        owner: walletClient.account.address,
+        spender: gatewayAddress
+      });
+      if (currentAllowance < peggedTokenIn) {
+        emitter.emit("pre-approve");
+        const approvalHash = await approve2(walletClient, {
+          address: peggedTokenAddress,
+          amount: resolvedApproveAmount,
+          spender: gatewayAddress
+        }).catch(function(error) {
+          emitter.emit("user-signing-approval-error", error);
+        });
+        if (!approvalHash) {
+          return;
+        }
+        emitter.emit("user-signed-approval", approvalHash);
+        const approvalReceipt = await waitForTransactionReceipt3(
+          walletClient,
+          {
+            hash: approvalHash
+          }
+        ).catch(function(error) {
+          emitter.emit("redeem-failed", error);
+        });
+        if (!approvalReceipt) {
+          return;
+        }
+        if (approvalReceipt.status === "reverted") {
+          emitter.emit("approve-transaction-reverted", approvalReceipt);
+          return;
+        }
+        emitter.emit("approve-transaction-succeeded", approvalReceipt);
+      }
+    }
+    emitter.emit("pre-redeem");
+    const redeemHash = await writeContract3(walletClient, {
+      abi: gatewayAbi,
+      account: walletClient.account,
+      address: gatewayAddress,
+      args: [tokenOut, peggedTokenIn, minAmountOut, receiver],
+      chain: walletClient.chain,
+      functionName: "redeem"
+    }).catch(function(error) {
+      emitter.emit("user-signing-redeem-error", error);
+    });
+    if (!redeemHash) {
+      return;
+    }
+    emitter.emit("user-signed-redeem", redeemHash);
+    const redeemReceipt = await waitForTransactionReceipt3(walletClient, {
+      hash: redeemHash
+    }).catch(function(error) {
+      emitter.emit("redeem-failed", error);
+    });
+    if (!redeemReceipt) {
+      return;
+    }
+    const redeemEventMap = {
+      reverted: "redeem-transaction-reverted",
+      success: "redeem-transaction-succeeded"
+    };
+    emitter.emit(redeemEventMap[redeemReceipt.status], redeemReceipt);
+  } catch (error) {
+    emitter.emit("unexpected-error", error);
+  } finally {
+    emitter.emit("redeem-settled");
+  }
+};
+var redeem = (...args) => toPromiseEvent3(runRedeem(...args));
+var encodeRedeem = ({
+  minAmountOut,
+  peggedTokenIn,
+  receiver,
+  tokenOut
+}) => encodeFunctionData3({
+  abi: gatewayAbi,
+  args: [tokenOut, peggedTokenIn, minAmountOut, receiver],
+  functionName: "redeem"
+});
+
+// src/actions/wallet/requestRedeem.ts
+import { toPromiseEvent as toPromiseEvent4 } from "to-promise-event";
+import {
+  encodeFunctionData as encodeFunctionData4,
+  isAddress as isAddress5,
+  isAddressEqual as isAddressEqual5,
+  zeroAddress as zeroAddress5
+} from "viem";
+import { waitForTransactionReceipt as waitForTransactionReceipt4, writeContract as writeContract4 } from "viem/actions";
+import { allowance as allowance3, approve as approve3 } from "viem-erc20/actions";
+var canRequestRedeem = function({
+  approveAmount,
+  client,
+  gatewayAddress,
+  peggedTokenAmount
+}) {
+  if (!client) {
+    return {
+      canRequestRedeem: false,
+      reason: "Client is not defined"
+    };
+  }
+  if (!client.chain) {
+    return {
+      canRequestRedeem: false,
+      reason: "Chain is not defined on wallet client"
+    };
+  }
+  if (!client.account) {
+    return {
+      canRequestRedeem: false,
+      reason: "Client must have an account"
+    };
+  }
+  if (!gatewayAddress || !isAddress5(gatewayAddress)) {
+    return {
+      canRequestRedeem: false,
+      reason: "Invalid gateway address"
+    };
+  }
+  if (isAddressEqual5(gatewayAddress, zeroAddress5)) {
+    return {
+      canRequestRedeem: false,
+      reason: "Gateway address cannot be zero address"
+    };
+  }
+  if (typeof peggedTokenAmount !== "bigint") {
+    return {
+      canRequestRedeem: false,
+      reason: "Amount must be a bigint"
+    };
+  }
+  if (peggedTokenAmount <= 0n) {
+    return {
+      canRequestRedeem: false,
+      reason: "Amount must be greater than 0"
+    };
+  }
+  if (approveAmount < peggedTokenAmount) {
+    return {
+      canRequestRedeem: false,
+      reason: "Approve amount must be greater than or equal to amount"
+    };
+  }
+  return { canRequestRedeem: true };
+};
+var runRequestRedeem = (walletClient, { approveAmount, gatewayAddress, peggedTokenAmount }) => async function(emitter) {
+  const resolvedApproveAmount = approveAmount ?? peggedTokenAmount;
+  try {
+    const { canRequestRedeem: canRequestRedeemFlag, reason } = canRequestRedeem({
+      approveAmount: resolvedApproveAmount,
+      client: walletClient,
+      gatewayAddress,
+      peggedTokenAmount
+    });
+    if (!canRequestRedeemFlag) {
+      emitter.emit("request-redeem-failed-validation", reason);
+      return;
+    }
+    const peggedTokenAddress = await getPeggedToken(walletClient, {
+      address: gatewayAddress
+    });
+    const currentAllowance = await allowance3(walletClient, {
+      address: peggedTokenAddress,
+      owner: walletClient.account.address,
+      spender: gatewayAddress
+    });
+    if (currentAllowance < peggedTokenAmount) {
+      emitter.emit("pre-approve");
+      const approvalHash = await approve3(walletClient, {
+        address: peggedTokenAddress,
+        amount: resolvedApproveAmount,
+        spender: gatewayAddress
+      }).catch(function(error) {
+        emitter.emit("user-signing-approval-error", error);
+      });
+      if (!approvalHash) {
+        return;
+      }
+      emitter.emit("user-signed-approval", approvalHash);
+      const approvalReceipt = await waitForTransactionReceipt4(walletClient, {
+        hash: approvalHash
+      }).catch(function(error) {
+        emitter.emit("request-redeem-failed", error);
+      });
+      if (!approvalReceipt) {
+        return;
+      }
+      if (approvalReceipt.status === "reverted") {
+        emitter.emit("approve-transaction-reverted", approvalReceipt);
+        return;
+      }
+      emitter.emit("approve-transaction-succeeded", approvalReceipt);
+    }
+    emitter.emit("pre-request-redeem");
+    const requestRedeemHash = await writeContract4(walletClient, {
+      abi: gatewayAbi,
+      account: walletClient.account,
+      address: gatewayAddress,
+      args: [peggedTokenAmount],
+      chain: walletClient.chain,
+      functionName: "requestRedeem"
+    }).catch(function(error) {
+      emitter.emit("user-signing-request-redeem-error", error);
+    });
+    if (!requestRedeemHash) {
+      return;
+    }
+    emitter.emit("user-signed-request-redeem", requestRedeemHash);
+    const requestRedeemReceipt = await waitForTransactionReceipt4(
+      walletClient,
+      {
+        hash: requestRedeemHash
+      }
+    ).catch(function(error) {
+      emitter.emit("request-redeem-failed", error);
+    });
+    if (!requestRedeemReceipt) {
+      return;
+    }
+    const requestRedeemEventMap = {
+      reverted: "request-redeem-transaction-reverted",
+      success: "request-redeem-transaction-succeeded"
+    };
+    emitter.emit(
+      requestRedeemEventMap[requestRedeemReceipt.status],
+      requestRedeemReceipt
+    );
+  } catch (error) {
+    emitter.emit("unexpected-error", error);
+  } finally {
+    emitter.emit("request-redeem-settled");
+  }
+};
+var requestRedeem = (...args) => toPromiseEvent4(runRequestRedeem(...args));
+var encodeRequestRedeem = ({
+  peggedTokenAmount
+}) => encodeFunctionData4({
+  abi: gatewayAbi,
+  args: [peggedTokenAmount],
+  functionName: "requestRedeem"
+});
+
+export {
+  gateways,
+  gatewayAddresses,
+  getGateway,
+  gatewayAbi,
+  getMaxMint,
+  getMaxWithdraw,
+  getMintFee,
+  getPeggedToken,
+  getRedeemFee,
+  getRedeemRequest,
+  getTreasury,
+  getWithdrawalDelay,
+  getWithdrawalDelayEnabled,
+  isInstantRedeemWhitelisted,
+  previewDeposit,
+  previewRedeem,
+  previewWithdraw,
+  cancelRedeemRequest,
+  encodeCancelRedeemRequest,
+  deposit,
+  encodeDeposit,
+  redeem,
+  encodeRedeem,
+  requestRedeem,
+  encodeRequestRedeem
+};
+//# sourceMappingURL=chunk-ZE4YZMXK.js.map