@vetro-protocol/gateway 1.0.0-beta

package/src/actions/public/getRedeemRequest.ts

@@ -0,0 +1,40 @@
+import { type Address, type Client } from "viem";
+import { readContract } from "viem/actions";
+
+import { gatewayAbi } from "../../abi/gatewayAbi.js";
+import { isAddressValid } from "../../utils/isAddressValid.js";
+
+export async function getRedeemRequest(
+  client: Client,
+  parameters: {
+    address: Address;
+    user: Address;
+  },
+) {
+  // Validate client
+  if (!client) {
+    throw new Error("Client is not defined");
+  }
+
+  // Validate parameters exist
+  if (!parameters) {
+    throw new Error("Parameters are required");
+  }
+
+  // Validate gateway address
+  if (!isAddressValid(parameters.address)) {
+    throw new Error("Gateway is invalid");
+  }
+
+  // Validate user address
+  if (!isAddressValid(parameters.user)) {
+    throw new Error("User is invalid");
+  }
+
+  return readContract(client, {
+    abi: gatewayAbi,
+    address: parameters.address,
+    args: [parameters.user],
+    functionName: "getRedeemRequest",
+  });
+}

package/src/actions/public/getTreasury.ts

@@ -0,0 +1,33 @@
+import { type Address, type Client } from "viem";
+import { readContract } from "viem/actions";
+
+import { gatewayAbi } from "../../abi/gatewayAbi.js";
+import { isAddressValid } from "../../utils/isAddressValid.js";
+
+export async function getTreasury(
+  client: Client,
+  parameters: {
+    address: Address;
+  },
+) {
+  // Validate client
+  if (!client) {
+    throw new Error("Client is not defined");
+  }
+
+  // Validate parameters exist
+  if (!parameters) {
+    throw new Error("Parameters are required");
+  }
+
+  // Validate gateway address
+  if (!isAddressValid(parameters.address)) {
+    throw new Error("Gateway is invalid");
+  }
+
+  return readContract(client, {
+    abi: gatewayAbi,
+    address: parameters.address,
+    functionName: "treasury",
+  });
+}

package/src/actions/public/getWithdrawalDelay.ts

@@ -0,0 +1,33 @@
+import { type Address, type Client } from "viem";
+import { readContract } from "viem/actions";
+
+import { gatewayAbi } from "../../abi/gatewayAbi.js";
+import { isAddressValid } from "../../utils/isAddressValid.js";
+
+export async function getWithdrawalDelay(
+  client: Client,
+  parameters: {
+    address: Address;
+  },
+) {
+  // Validate client
+  if (!client) {
+    throw new Error("Client is not defined");
+  }
+
+  // Validate parameters exist
+  if (!parameters) {
+    throw new Error("Parameters are required");
+  }
+
+  // Validate gateway address
+  if (!isAddressValid(parameters.address)) {
+    throw new Error("Gateway is invalid");
+  }
+
+  return readContract(client, {
+    abi: gatewayAbi,
+    address: parameters.address,
+    functionName: "withdrawalDelay",
+  });
+}

package/src/actions/public/getWithdrawalDelayEnabled.ts

@@ -0,0 +1,33 @@
+import { type Address, type Client } from "viem";
+import { readContract } from "viem/actions";
+
+import { gatewayAbi } from "../../abi/gatewayAbi.js";
+import { isAddressValid } from "../../utils/isAddressValid.js";
+
+export async function getWithdrawalDelayEnabled(
+  client: Client,
+  parameters: {
+    address: Address;
+  },
+) {
+  // Validate client
+  if (!client) {
+    throw new Error("Client is not defined");
+  }
+
+  // Validate parameters exist
+  if (!parameters) {
+    throw new Error("Parameters are required");
+  }
+
+  // Validate gateway address
+  if (!isAddressValid(parameters.address)) {
+    throw new Error("Gateway is invalid");
+  }
+
+  return readContract(client, {
+    abi: gatewayAbi,
+    address: parameters.address,
+    functionName: "withdrawalDelayEnabled",
+  });
+}

package/src/actions/public/index.ts

@@ -0,0 +1,11 @@
+export * from "./getMaxWithdraw.js";
+export * from "./getMintFee.js";
+export * from "./getPeggedToken.js";
+export * from "./getRedeemFee.js";
+export * from "./getRedeemRequest.js";
+export * from "./getTreasury.js";
+export * from "./getWithdrawalDelay.js";
+export * from "./getWithdrawalDelayEnabled.js";
+export * from "./isInstantRedeemWhitelisted.js";
+export * from "./previewDeposit.js";
+export * from "./previewRedeem.js";

package/src/actions/public/isInstantRedeemWhitelisted.ts

@@ -0,0 +1,40 @@
+import { type Address, type Client } from "viem";
+import { readContract } from "viem/actions";
+
+import { gatewayAbi } from "../../abi/gatewayAbi.js";
+import { isAddressValid } from "../../utils/isAddressValid.js";
+
+export async function isInstantRedeemWhitelisted(
+  client: Client,
+  parameters: {
+    address: Address;
+    account: Address;
+  },
+) {
+  // Validate client
+  if (!client) {
+    throw new Error("Client is not defined");
+  }
+
+  // Validate parameters exist
+  if (!parameters) {
+    throw new Error("Parameters are required");
+  }
+
+  // Validate gateway address
+  if (!isAddressValid(parameters.address)) {
+    throw new Error("Gateway is invalid");
+  }
+
+  // Validate account address
+  if (!isAddressValid(parameters.account)) {
+    throw new Error("Account is invalid");
+  }
+
+  return readContract(client, {
+    abi: gatewayAbi,
+    address: parameters.address,
+    args: [parameters.account],
+    functionName: "isInstantRedeemWhitelisted",
+  });
+}

package/src/actions/public/previewDeposit.ts

@@ -0,0 +1,49 @@
+import { type Address, type Client } from "viem";
+import { readContract } from "viem/actions";
+
+import { gatewayAbi } from "../../abi/gatewayAbi.js";
+import { isAddressValid } from "../../utils/isAddressValid.js";
+
+export async function previewDeposit(
+  client: Client,
+  parameters: {
+    address: Address;
+    tokenIn: Address;
+    amountIn: bigint;
+  },
+) {
+  // Validate client
+  if (!client) {
+    throw new Error("Client is not defined");
+  }
+
+  // Validate parameters exist
+  if (!parameters) {
+    throw new Error("Parameters are required");
+  }
+
+  // Validate gateway address
+  if (!isAddressValid(parameters.address)) {
+    throw new Error("Gateway is invalid");
+  }
+
+  // Validate tokenIn address
+  if (!isAddressValid(parameters.tokenIn)) {
+    throw new Error("Token is invalid");
+  }
+
+  // Validate amountIn
+  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 readContract(client, {
+    abi: gatewayAbi,
+    address: parameters.address,
+    args: [parameters.tokenIn, parameters.amountIn],
+    functionName: "previewDeposit",
+  });
+}

package/src/actions/public/previewRedeem.ts

@@ -0,0 +1,49 @@
+import { type Address, type Client } from "viem";
+import { readContract } from "viem/actions";
+
+import { gatewayAbi } from "../../abi/gatewayAbi.js";
+import { isAddressValid } from "../../utils/isAddressValid.js";
+
+export async function previewRedeem(
+  client: Client,
+  parameters: {
+    address: Address;
+    tokenOut: Address;
+    peggedTokenIn: bigint;
+  },
+) {
+  // Validate client
+  if (!client) {
+    throw new Error("Client is not defined");
+  }
+
+  // Validate parameters exist
+  if (!parameters) {
+    throw new Error("Parameters are required");
+  }
+
+  // Validate gateway address
+  if (!isAddressValid(parameters.address)) {
+    throw new Error("Gateway is invalid");
+  }
+
+  // Validate tokenOut address
+  if (!isAddressValid(parameters.tokenOut)) {
+    throw new Error("Token is invalid");
+  }
+
+  // Validate peggedTokenIn
+  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 readContract(client, {
+    abi: gatewayAbi,
+    address: parameters.address,
+    args: [parameters.tokenOut, parameters.peggedTokenIn],
+    functionName: "previewRedeem",
+  });
+}

package/src/actions/wallet/cancelRedeemRequest.ts

@@ -0,0 +1,135 @@
+import { EventEmitter } from "events";
+import { toPromiseEvent } from "to-promise-event";
+import {
+  type Address,
+  type TransactionReceipt,
+  type WalletClient,
+  encodeFunctionData,
+  isAddress,
+  isAddressEqual,
+  zeroAddress,
+} from "viem";
+import { waitForTransactionReceipt, writeContract } from "viem/actions";
+
+import { gatewayAbi } from "../../abi/gatewayAbi.js";
+import type { CancelRedeemRequestEvents } from "../../types.js";
+
+export type CancelRedeemRequestParams = {
+  gatewayAddress: Address;
+};
+
+const canCancelRedeemRequest = function ({
+  client,
+  gatewayAddress,
+}: {
+  client: WalletClient;
+  gatewayAddress: Address;
+}): {
+  canCancelRedeemRequest: boolean;
+  reason?: string;
+} {
+  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",
+    };
+  }
+  // Validate gateway address
+  if (!gatewayAddress || !isAddress(gatewayAddress)) {
+    return {
+      canCancelRedeemRequest: false,
+      reason: "Invalid gateway address",
+    };
+  }
+  if (isAddressEqual(gatewayAddress, zeroAddress)) {
+    return {
+      canCancelRedeemRequest: false,
+      reason: "Gateway address cannot be zero address",
+    };
+  }
+
+  return { canCancelRedeemRequest: true };
+};
+
+const runCancelRedeemRequest = (
+  walletClient: WalletClient,
+  { gatewayAddress }: CancelRedeemRequestParams,
+) =>
+  async function (emitter: EventEmitter<CancelRedeemRequestEvents>) {
+    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: 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: Error) {
+        emitter.emit("cancel-redeem-request-failed", error);
+      });
+
+      if (!cancelReceipt) {
+        return;
+      }
+
+      const cancelEventMap: Record<
+        TransactionReceipt["status"],
+        keyof CancelRedeemRequestEvents
+      > = {
+        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 as Error);
+    } finally {
+      emitter.emit("cancel-redeem-request-settled");
+    }
+  };
+
+export const cancelRedeemRequest = (
+  ...args: Parameters<typeof runCancelRedeemRequest>
+) => toPromiseEvent<CancelRedeemRequestEvents>(runCancelRedeemRequest(...args));
+
+export const encodeCancelRedeemRequest = () =>
+  encodeFunctionData({
+    abi: gatewayAbi,
+    functionName: "cancelRedeemRequest",
+  });

package/src/actions/wallet/deposit.ts

@@ -0,0 +1,277 @@
+import { EventEmitter } from "events";
+import { toPromiseEvent } from "to-promise-event";
+import {
+  type Address,
+  type TransactionReceipt,
+  type WalletClient,
+  encodeFunctionData,
+  isAddress,
+  isAddressEqual,
+  zeroAddress,
+} from "viem";
+import { waitForTransactionReceipt, writeContract } from "viem/actions";
+import { allowance, approve } from "viem-erc20/actions";
+
+import { gatewayAbi } from "../../abi/gatewayAbi.js";
+import type { DepositEvents } from "../../types.js";
+
+export type DepositParams = {
+  amountIn: bigint;
+  approveAmount?: bigint;
+  gatewayAddress: Address;
+  minPeggedTokenOut: bigint;
+  receiver: Address;
+  tokenIn: Address;
+};
+
+const canDeposit = function ({
+  amountIn,
+  approveAmount,
+  client,
+  gatewayAddress,
+  minPeggedTokenOut,
+  receiver,
+  tokenIn,
+}: {
+  amountIn: bigint;
+  approveAmount: bigint;
+  client: WalletClient;
+  gatewayAddress: Address;
+  minPeggedTokenOut: bigint;
+  receiver: Address;
+  tokenIn: Address;
+}): {
+  canDeposit: boolean;
+  reason?: string;
+} {
+  // Validate client
+  if (!client) {
+    return {
+      canDeposit: false,
+      reason: "Client is not defined",
+    };
+  }
+  if (!client.chain) {
+    return {
+      canDeposit: false,
+      reason: "Chain is not defined on wallet client",
+    };
+  }
+  // Validate client has required properties
+  if (!client.account) {
+    return {
+      canDeposit: false,
+      reason: "Client must have an account",
+    };
+  }
+  // Validate gateway address
+  if (!gatewayAddress || !isAddress(gatewayAddress)) {
+    return {
+      canDeposit: false,
+      reason: "Invalid gateway address",
+    };
+  }
+  if (isAddressEqual(gatewayAddress, zeroAddress)) {
+    return {
+      canDeposit: false,
+      reason: "Gateway address cannot be zero address",
+    };
+  }
+  // Validate tokenIn address
+  if (!tokenIn || !isAddress(tokenIn)) {
+    return {
+      canDeposit: false,
+      reason: "Invalid token address",
+    };
+  }
+  if (isAddressEqual(tokenIn, zeroAddress)) {
+    return {
+      canDeposit: false,
+      reason: "Token address cannot be zero address",
+    };
+  }
+
+  // Validate receiver address
+  if (!receiver || !isAddress(receiver)) {
+    return {
+      canDeposit: false,
+      reason: "Invalid receiver address",
+    };
+  }
+  if (isAddressEqual(receiver, zeroAddress)) {
+    return {
+      canDeposit: false,
+      reason: "Receiver address cannot be zero address",
+    };
+  }
+
+  // Validate amountIn
+  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",
+    };
+  }
+
+  // Validate minPeggedTokenOut
+  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",
+    };
+  }
+
+  // Validate approveAmount
+  if (approveAmount < amountIn) {
+    return {
+      canDeposit: false,
+      reason: "Approve amount must be greater than or equal to amount",
+    };
+  }
+
+  return { canDeposit: true };
+};
+
+const runDeposit = (
+  walletClient: WalletClient,
+  {
+    amountIn,
+    approveAmount = amountIn,
+    gatewayAddress,
+    minPeggedTokenOut,
+    receiver,
+    tokenIn,
+  }: DepositParams,
+) =>
+  async function (emitter: EventEmitter<DepositEvents>) {
+    try {
+      const { canDeposit: canDepositFlag, reason } = canDeposit({
+        amountIn,
+        approveAmount,
+        client: walletClient,
+        gatewayAddress,
+        minPeggedTokenOut,
+        receiver,
+        tokenIn,
+      });
+
+      if (!canDepositFlag) {
+        emitter.emit("deposit-failed-validation", reason!);
+        return;
+      }
+
+      // Check current allowance
+      const currentAllowance = await allowance(walletClient, {
+        address: tokenIn,
+        // account is already validated
+        owner: walletClient.account!.address,
+        spender: gatewayAddress,
+      });
+
+      // If allowance is insufficient, approve first
+      if (currentAllowance < amountIn) {
+        emitter.emit("pre-approve");
+
+        const approvalHash = await approve(walletClient, {
+          address: tokenIn,
+          amount: approveAmount,
+          spender: gatewayAddress,
+        }).catch(function (error: Error) {
+          emitter.emit("user-signing-approval-error", error);
+        });
+
+        if (!approvalHash) {
+          return;
+        }
+
+        emitter.emit("user-signed-approval", approvalHash);
+
+        const approvalReceipt = await waitForTransactionReceipt(walletClient, {
+          hash: approvalHash,
+        }).catch(function (error: 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 writeContract(walletClient, {
+        abi: gatewayAbi,
+        account: walletClient.account!,
+        address: gatewayAddress,
+        args: [tokenIn, amountIn, minPeggedTokenOut, receiver],
+        chain: walletClient.chain,
+        functionName: "deposit",
+      }).catch(function (error: Error) {
+        emitter.emit("user-signing-deposit-error", error);
+      });
+
+      if (!depositHash) {
+        return;
+      }
+
+      emitter.emit("user-signed-deposit", depositHash);
+
+      const depositReceipt = await waitForTransactionReceipt(walletClient, {
+        hash: depositHash,
+      }).catch(function (error: Error) {
+        emitter.emit("deposit-failed", error);
+      });
+
+      if (!depositReceipt) {
+        return;
+      }
+
+      const depositEventMap: Record<
+        TransactionReceipt["status"],
+        keyof DepositEvents
+      > = {
+        reverted: "deposit-transaction-reverted",
+        success: "deposit-transaction-succeeded",
+      };
+
+      emitter.emit(depositEventMap[depositReceipt.status], depositReceipt);
+    } catch (error) {
+      emitter.emit("unexpected-error", error as Error);
+    } finally {
+      emitter.emit("deposit-settled");
+    }
+  };
+
+export const deposit = (...args: Parameters<typeof runDeposit>) =>
+  toPromiseEvent<DepositEvents>(runDeposit(...args));
+
+export const encodeDeposit = ({
+  amountIn,
+  minPeggedTokenOut,
+  receiver,
+  tokenIn,
+}: Omit<DepositParams, "gatewayAddress">) =>
+  encodeFunctionData({
+    abi: gatewayAbi,
+    args: [tokenIn, amountIn, minPeggedTokenOut, receiver],
+    functionName: "deposit",
+  });