deploy-sdk 0.0.1

package/dist/chunk-X3SXEVUG.mjs

@@ -0,0 +1,732 @@
+// src/modules/mint/MintModule.ts
+import { Contract } from "ethers";
+
+// src/core/errors.ts
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2["NOT_INITIALIZED"] = "NOT_INITIALIZED";
+  ErrorCode2["WALLET_NOT_CONNECTED"] = "WALLET_NOT_CONNECTED";
+  ErrorCode2["INVALID_CHAIN"] = "INVALID_CHAIN";
+  ErrorCode2["INSUFFICIENT_BALANCE"] = "INSUFFICIENT_BALANCE";
+  ErrorCode2["INSUFFICIENT_ALLOWANCE"] = "INSUFFICIENT_ALLOWANCE";
+  ErrorCode2["TRANSACTION_FAILED"] = "TRANSACTION_FAILED";
+  ErrorCode2["STAKE_FAILED"] = "STAKE_FAILED";
+  ErrorCode2["UNSTAKE_FAILED"] = "UNSTAKE_FAILED";
+  ErrorCode2["COOLDOWN_FAILED"] = "COOLDOWN_FAILED";
+  ErrorCode2["MINT_FAILED"] = "MINT_FAILED";
+  ErrorCode2["REDEEM_FAILED"] = "REDEEM_FAILED";
+  ErrorCode2["INVALID_ORDER"] = "INVALID_ORDER";
+  ErrorCode2["SIGNATURE_FAILED"] = "SIGNATURE_FAILED";
+  ErrorCode2["API_ERROR"] = "API_ERROR";
+  ErrorCode2["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+  return ErrorCode2;
+})(ErrorCode || {});
+var DeploySDKError = class _DeploySDKError extends Error {
+  constructor(code, message, originalError) {
+    super(message);
+    this.name = "DeploySDKError";
+    this.code = code;
+    this.originalError = originalError;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _DeploySDKError);
+    }
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      originalError: this.originalError?.message || this.originalError
+    };
+  }
+};
+
+// src/core/constants.ts
+var CONTRACT_ADDRESSES = {
+  [1 /* ETHEREUM */]: {
+    USDC: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+    USDT: "0xdac17f958d2ee523a2206206994597c13d831ec7",
+    dUSD: "0xf42e0b98e32150fe02a370456e6479fcd94f5531",
+    DUSD_MINTER: "0x1ee453Ea35f6EAbD9BFF126586322cbC906D4EB3",
+    sDUSD_STAKING: "0x7f37B0133B1adC1D0647EE52eA38fA13caC4aA1B"
+  },
+  [42161 /* ARBITRUM */]: {}
+};
+var COLLATERAL_ASSETS = {
+  USDC: {
+    key: "USDC",
+    name: "USD Coin",
+    symbol: "USDC",
+    address: CONTRACT_ADDRESSES[1 /* ETHEREUM */].USDC,
+    decimals: 6,
+    mintingContract: CONTRACT_ADDRESSES[1 /* ETHEREUM */].DUSD_MINTER
+  },
+  USDT: {
+    key: "USDT",
+    name: "Tether USD",
+    symbol: "USDT",
+    address: CONTRACT_ADDRESSES[1 /* ETHEREUM */].USDT,
+    decimals: 6,
+    mintingContract: CONTRACT_ADDRESSES[1 /* ETHEREUM */].DUSD_MINTER
+  }
+};
+var STAKE_TOKENS = {
+  dUSD: {
+    key: "dUSD",
+    name: "Deploy USD",
+    symbol: "dUSD",
+    address: CONTRACT_ADDRESSES[1 /* ETHEREUM */].dUSD,
+    decimals: 18,
+    supportedCollateral: [COLLATERAL_ASSETS.USDC, COLLATERAL_ASSETS.USDT],
+    stakingContract: CONTRACT_ADDRESSES[1 /* ETHEREUM */].sDUSD_STAKING,
+    stakingSymbol: "sDUSD",
+    cooldownPeriod: 90 * 24 * 60 * 60 * 1e3
+  }
+};
+var EIP712_TYPES_ORDER = {
+  Order: [
+    { name: "order_id", type: "string" },
+    { name: "order_type", type: "uint8" },
+    { name: "expiry", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "benefactor", type: "address" },
+    { name: "beneficiary", type: "address" },
+    { name: "collateral_asset", type: "address" },
+    { name: "collateral_amount", type: "uint256" },
+    { name: "dAsset_amount", type: "uint256" }
+  ]
+};
+var ERC4626_ABI = [
+  "function deposit(uint256 assets, address receiver) external returns (uint256 shares)",
+  "function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares)",
+  "function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets)",
+  "function cooldownShares(uint256 shares) external",
+  "function cooldowns(address user) external view returns (uint256 cooldownEnd, uint256 underlyingAmount)",
+  "function balanceOf(address owner) external view returns (uint256)",
+  "function convertToShares(uint256 assets) external view returns (uint256)",
+  "function convertToAssets(uint256 shares) external view returns (uint256)",
+  "function totalAssets() external view returns (uint256)",
+  "function totalSupply() external view returns (uint256)",
+  "event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares)",
+  "event Withdraw(address indexed sender, address indexed receiver, address indexed owner, uint256 assets, uint256 shares)"
+];
+var ERC20_ABI = [
+  "function approve(address spender, uint256 amount) external returns (bool)",
+  "function allowance(address owner, address spender) external view returns (uint256)",
+  "function balanceOf(address account) external view returns (uint256)",
+  "function decimals() external view returns (uint8)",
+  "function symbol() external view returns (string)",
+  "function name() external view returns (string)",
+  "function transfer(address recipient, uint256 amount) external returns (bool)",
+  "function transferFrom(address sender, address recipient, uint256 amount) external returns (bool)",
+  "event Approval(address indexed owner, address indexed spender, uint256 value)",
+  "event Transfer(address indexed from, address indexed to, uint256 value)"
+];
+var MINTER_ABI = [
+  "function mint(tuple(string order_id, uint8 order_type, uint256 expiry, uint256 nonce, address benefactor, address beneficiary, address collateral_asset, uint256 collateral_amount, uint256 dAsset_amount) order, tuple(address[] addresses, uint256[] ratios) route, tuple(uint8 signature_type, bytes signature_bytes) signature) external",
+  "function redeem(tuple(string order_id, uint8 order_type, uint256 expiry, uint256 nonce, address benefactor, address beneficiary, address collateral_asset, uint256 collateral_amount, uint256 dAsset_amount) order, tuple(uint8 signature_type, bytes signature_bytes) signature) external",
+  "function isWhitelistedBenefactor(address benefactor) external view returns (bool)",
+  "function addWhitelistedBenefactor(address benefactor) external",
+  "function removeWhitelistedBenefactor(address benefactor) external"
+];
+
+// src/modules/mint/MintModule.ts
+import { v4 as uuidv4 } from "uuid";
+var MintModule = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  async createOrder(collateralAsset, collateralAmount, dAssetAmount, options) {
+    const address = await this.sdk.getAddress();
+    const orderId = uuidv4();
+    const expiry = Math.floor(Date.now() / 1e3) + (options?.expiryMinutes || 5) * 60;
+    const minterAddress = collateralAsset.mintingContract;
+    const order = {
+      orderId,
+      orderType: 0,
+      expiry,
+      nonce: Date.now(),
+      benefactor: options?.benefactor || address,
+      beneficiary: options?.beneficiary || address,
+      collateralAsset: collateralAsset.address,
+      collateralAmount: collateralAmount.toString(),
+      dAssetAmount: dAssetAmount.toString(),
+      minterAddress
+    };
+    return order;
+  }
+  async signOrder(order) {
+    const signer = this.sdk.signer;
+    const domain = {
+      name: "DeployMinting",
+      version: "1",
+      chainId: await this.sdk.getChainId(),
+      verifyingContract: order.minterAddress
+    };
+    const value = {
+      order_id: order.orderId,
+      order_type: order.orderType,
+      expiry: order.expiry,
+      nonce: order.nonce,
+      benefactor: order.benefactor,
+      beneficiary: order.beneficiary,
+      collateral_asset: order.collateralAsset,
+      collateral_amount: order.collateralAmount,
+      dAsset_amount: order.dAssetAmount
+    };
+    try {
+      const signature = await signer._signTypedData(domain, EIP712_TYPES_ORDER, value);
+      return signature;
+    } catch (error) {
+      throw new DeploySDKError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        "Failed to sign mint order",
+        error
+      );
+    }
+  }
+  async submitOrder(order, signature) {
+    try {
+      const response = await fetch(`${this.sdk.config.apiUrl}/api/mint`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          order: {
+            order_id: order.orderId,
+            order_type: order.orderType,
+            expiry: order.expiry,
+            nonce: order.nonce,
+            benefactor: order.benefactor,
+            beneficiary: order.beneficiary,
+            collateral_asset: order.collateralAsset,
+            collateral_amount: order.collateralAmount,
+            dAsset_amount: order.dAssetAmount
+          },
+          signature: {
+            signature_type: 0,
+            signature_bytes: signature
+          }
+        })
+      });
+      if (!response.ok) {
+        const error = await response.json();
+        throw new DeploySDKError(
+          "API_ERROR" /* API_ERROR */,
+          error.message || "Failed to submit mint order"
+        );
+      }
+      const result = await response.json();
+      return {
+        success: true,
+        orderId: order.orderId,
+        txHash: result.txHash,
+        status: result.status
+      };
+    } catch (error) {
+      if (error instanceof DeploySDKError) throw error;
+      throw new DeploySDKError(
+        "API_ERROR" /* API_ERROR */,
+        "Failed to submit mint order",
+        error
+      );
+    }
+  }
+  async mint(collateralAsset, collateralAmount, dAssetAmount, options) {
+    try {
+      const order = await this.createOrder(
+        collateralAsset,
+        collateralAmount,
+        dAssetAmount,
+        options
+      );
+      const signature = await this.signOrder(order);
+      return await this.submitOrder(order, signature);
+    } catch (error) {
+      if (error instanceof DeploySDKError) throw error;
+      throw new DeploySDKError(
+        "MINT_FAILED" /* MINT_FAILED */,
+        "Failed to mint tokens",
+        error
+      );
+    }
+  }
+  async estimateGas(collateralAsset, collateralAmount, dAssetAmount, signature) {
+    const minterContract = new Contract(
+      collateralAsset.mintingContract,
+      MINTER_ABI,
+      this.sdk.provider
+    );
+    const order = {
+      order_id: uuidv4(),
+      order_type: 0,
+      expiry: Math.floor(Date.now() / 1e3) + 300,
+      nonce: Date.now(),
+      benefactor: await this.sdk.getAddress(),
+      beneficiary: await this.sdk.getAddress(),
+      collateral_asset: collateralAsset.address,
+      collateral_amount: collateralAmount.toString(),
+      dAsset_amount: dAssetAmount.toString()
+    };
+    try {
+      const gasEstimate = await minterContract.estimateGas.mint(
+        order,
+        { addresses: [], ratios: [] },
+        { signature_type: 0, signature_bytes: signature }
+      );
+      return gasEstimate.toBigInt();
+    } catch (error) {
+      throw new DeploySDKError(
+        "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+        "Failed to estimate gas for mint",
+        error
+      );
+    }
+  }
+};
+
+// src/modules/stake/StakeModule.ts
+import { Contract as Contract2, BigNumber } from "ethers";
+var StakeModule = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  async stake(params) {
+    try {
+      const { token, amount, receiver } = params;
+      if (!token.stakingContract) {
+        throw new DeploySDKError(
+          "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+          `Token ${token.symbol} does not support staking`
+        );
+      }
+      const vaultContract = new Contract2(
+        token.stakingContract,
+        ERC4626_ABI,
+        this.sdk.signer
+      );
+      const receiverAddress = receiver || await this.sdk.getAddress();
+      const tx = await vaultContract.deposit(amount, receiverAddress);
+      const receipt = await tx.wait();
+      let sharesReceived;
+      const depositEvent = receipt.events?.find(
+        (e) => e.event === "Deposit"
+      );
+      if (depositEvent) {
+        sharesReceived = depositEvent.args?.shares?.toString();
+      }
+      return {
+        success: true,
+        txHash: receipt.transactionHash,
+        sharesReceived
+      };
+    } catch (error) {
+      if (error instanceof DeploySDKError) throw error;
+      throw new DeploySDKError(
+        "STAKE_FAILED" /* STAKE_FAILED */,
+        "Failed to stake tokens",
+        error
+      );
+    }
+  }
+  async getPosition(token, userAddress) {
+    if (!token.stakingContract) {
+      throw new DeploySDKError(
+        "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+        `Token ${token.symbol} does not support staking`
+      );
+    }
+    const address = userAddress || await this.sdk.getAddress();
+    const vaultContract = new Contract2(
+      token.stakingContract,
+      ERC4626_ABI,
+      this.sdk.provider
+    );
+    try {
+      const [shares, assets, cooldown] = await Promise.all([
+        vaultContract.balanceOf(address),
+        vaultContract.convertToAssets(await vaultContract.balanceOf(address)),
+        vaultContract.cooldowns(address).catch(() => ({ cooldownEnd: BigNumber.from(0), underlyingAmount: BigNumber.from(0) }))
+      ]);
+      const cooldownEnd = cooldown.cooldownEnd.toNumber() * 1e3;
+      return {
+        tokenKey: token.key,
+        stakedAmount: shares.toString(),
+        stakedValue: assets.toString(),
+        cooldownEnd: cooldownEnd > 0 ? cooldownEnd : void 0,
+        canUnstake: cooldownEnd === 0 || cooldownEnd <= Date.now()
+      };
+    } catch (error) {
+      throw new DeploySDKError(
+        "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+        "Failed to fetch staking position",
+        error
+      );
+    }
+  }
+  async previewStake(token, amount) {
+    if (!token.stakingContract) {
+      throw new DeploySDKError(
+        "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+        `Token ${token.symbol} does not support staking`
+      );
+    }
+    const vaultContract = new Contract2(
+      token.stakingContract,
+      ERC4626_ABI,
+      this.sdk.provider
+    );
+    try {
+      const shares = await vaultContract.convertToShares(amount);
+      return {
+        shares: shares.toString(),
+        assets: amount.toString()
+      };
+    } catch (error) {
+      throw new DeploySDKError(
+        "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+        "Failed to preview stake",
+        error
+      );
+    }
+  }
+  async getAPY(token) {
+    if (!token.stakingContract) {
+      return 0;
+    }
+    const vaultContract = new Contract2(
+      token.stakingContract,
+      ERC4626_ABI,
+      this.sdk.provider
+    );
+    try {
+      const [totalAssets, totalSupply] = await Promise.all([
+        vaultContract.totalAssets(),
+        vaultContract.totalSupply()
+      ]);
+      if (totalSupply.isZero()) {
+        return 0;
+      }
+      const sharePrice = totalAssets.mul(BigNumber.from(10).pow(18)).div(totalSupply);
+      const basePrice = BigNumber.from(10).pow(18);
+      if (sharePrice.lte(basePrice)) {
+        return 0;
+      }
+      const yieldPerShare = sharePrice.sub(basePrice);
+      const dailyYield = yieldPerShare.mul(365);
+      const apy = dailyYield.mul(1e4).div(basePrice).toNumber() / 100;
+      return apy;
+    } catch (error) {
+      return 0;
+    }
+  }
+};
+
+// src/modules/unstake/UnstakeModule.ts
+import { Contract as Contract3 } from "ethers";
+var UnstakeModule = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  async initiateCooldown(token, sharesAmount) {
+    try {
+      if (!token.stakingContract) {
+        throw new DeploySDKError(
+          "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+          `Token ${token.symbol} does not support staking`
+        );
+      }
+      const vaultContract = new Contract3(
+        token.stakingContract,
+        ERC4626_ABI,
+        this.sdk.signer
+      );
+      const tx = await vaultContract.cooldownShares(sharesAmount);
+      const receipt = await tx.wait();
+      const cooldownEnd = Date.now() + (token.cooldownPeriod || 90 * 24 * 60 * 60 * 1e3);
+      return {
+        success: true,
+        txHash: receipt.transactionHash,
+        cooldownEnd
+      };
+    } catch (error) {
+      if (error instanceof DeploySDKError) throw error;
+      throw new DeploySDKError(
+        "COOLDOWN_FAILED" /* COOLDOWN_FAILED */,
+        "Failed to initiate cooldown",
+        error
+      );
+    }
+  }
+  async unstake(params) {
+    try {
+      const { token, sharesAmount, receiver } = params;
+      if (!token.stakingContract) {
+        throw new DeploySDKError(
+          "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+          `Token ${token.symbol} does not support staking`
+        );
+      }
+      const cooldownStatus = await this.getCooldownStatus(token);
+      if (!cooldownStatus.canUnstake) {
+        throw new DeploySDKError(
+          "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+          `Cannot unstake. Cooldown ends at ${new Date(cooldownStatus.cooldownEnd).toLocaleString()}`
+        );
+      }
+      const vaultContract = new Contract3(
+        token.stakingContract,
+        ERC4626_ABI,
+        this.sdk.signer
+      );
+      const receiverAddress = receiver || await this.sdk.getAddress();
+      const owner = await this.sdk.getAddress();
+      const tx = await vaultContract.redeem(sharesAmount, receiverAddress, owner);
+      const receipt = await tx.wait();
+      let assetsWithdrawn;
+      const withdrawEvent = receipt.events?.find(
+        (e) => e.event === "Withdraw"
+      );
+      if (withdrawEvent) {
+        assetsWithdrawn = withdrawEvent.args?.assets?.toString();
+      }
+      return {
+        success: true,
+        txHash: receipt.transactionHash,
+        assetsWithdrawn
+      };
+    } catch (error) {
+      if (error instanceof DeploySDKError) throw error;
+      throw new DeploySDKError(
+        "UNSTAKE_FAILED" /* UNSTAKE_FAILED */,
+        "Failed to unstake tokens",
+        error
+      );
+    }
+  }
+  async getCooldownStatus(token, userAddress) {
+    if (!token.stakingContract) {
+      throw new DeploySDKError(
+        "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+        `Token ${token.symbol} does not support staking`
+      );
+    }
+    const address = userAddress || await this.sdk.getAddress();
+    const vaultContract = new Contract3(
+      token.stakingContract,
+      ERC4626_ABI,
+      this.sdk.provider
+    );
+    try {
+      const cooldown = await vaultContract.cooldowns(address);
+      const cooldownEnd = cooldown.cooldownEnd.toNumber() * 1e3;
+      return {
+        cooldownEnd,
+        sharesInCooldown: cooldown.underlyingAmount.toString(),
+        canUnstake: cooldownEnd > 0 && cooldownEnd <= Date.now()
+      };
+    } catch (error) {
+      throw new DeploySDKError(
+        "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+        "Failed to fetch cooldown status",
+        error
+      );
+    }
+  }
+  async previewUnstake(token, sharesAmount) {
+    if (!token.stakingContract) {
+      throw new DeploySDKError(
+        "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+        `Token ${token.symbol} does not support staking`
+      );
+    }
+    const vaultContract = new Contract3(
+      token.stakingContract,
+      ERC4626_ABI,
+      this.sdk.provider
+    );
+    try {
+      const assets = await vaultContract.convertToAssets(sharesAmount);
+      return assets.toString();
+    } catch (error) {
+      throw new DeploySDKError(
+        "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+        "Failed to preview unstake",
+        error
+      );
+    }
+  }
+};
+
+// src/modules/redeem/RedeemModule.ts
+import { Contract as Contract4 } from "ethers";
+import { v4 as uuidv42 } from "uuid";
+var RedeemModule = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  async createOrder(token, redeemAmount, collateralAsset, collateralAmount, options) {
+    const address = await this.sdk.getAddress();
+    const orderId = uuidv42();
+    const expiry = Math.floor(Date.now() / 1e3) + (options?.expiryMinutes || 5) * 60;
+    const minterAddress = token.mintingContract;
+    const order = {
+      orderId,
+      orderType: 1,
+      expiry,
+      nonce: Date.now(),
+      benefactor: options?.benefactor || address,
+      beneficiary: options?.beneficiary || address,
+      collateralAsset,
+      collateralAmount: collateralAmount.toString(),
+      dAssetAmount: redeemAmount.toString(),
+      minterAddress
+    };
+    return order;
+  }
+  async signOrder(order) {
+    const signer = this.sdk.signer;
+    const domain = {
+      name: "DeployMinting",
+      version: "1",
+      chainId: await this.sdk.getChainId(),
+      verifyingContract: order.minterAddress
+    };
+    const value = {
+      order_id: order.orderId,
+      order_type: order.orderType,
+      expiry: order.expiry,
+      nonce: order.nonce,
+      benefactor: order.benefactor,
+      beneficiary: order.beneficiary,
+      collateral_asset: order.collateralAsset,
+      collateral_amount: order.collateralAmount,
+      dAsset_amount: order.dAssetAmount
+    };
+    try {
+      const signature = await signer._signTypedData(domain, EIP712_TYPES_ORDER, value);
+      return signature;
+    } catch (error) {
+      throw new DeploySDKError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        "Failed to sign redeem order",
+        error
+      );
+    }
+  }
+  async submitOrder(order, signature) {
+    try {
+      const response = await fetch(`${this.sdk.config.apiUrl}/api/redeem`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          order: {
+            order_id: order.orderId,
+            order_type: order.orderType,
+            expiry: order.expiry,
+            nonce: order.nonce,
+            benefactor: order.benefactor,
+            beneficiary: order.beneficiary,
+            collateral_asset: order.collateralAsset,
+            collateral_amount: order.collateralAmount,
+            dAsset_amount: order.dAssetAmount
+          },
+          signature: {
+            signature_type: 0,
+            signature_bytes: signature
+          }
+        })
+      });
+      if (!response.ok) {
+        const error = await response.json();
+        throw new DeploySDKError(
+          "API_ERROR" /* API_ERROR */,
+          error.message || "Failed to submit redeem order"
+        );
+      }
+      const result = await response.json();
+      return {
+        success: true,
+        orderId: order.orderId,
+        txHash: result.txHash,
+        status: result.status
+      };
+    } catch (error) {
+      if (error instanceof DeploySDKError) throw error;
+      throw new DeploySDKError(
+        "API_ERROR" /* API_ERROR */,
+        "Failed to submit redeem order",
+        error
+      );
+    }
+  }
+  async redeem(token, redeemAmount, collateralAsset, collateralAmount, options) {
+    try {
+      const order = await this.createOrder(
+        token,
+        redeemAmount,
+        collateralAsset,
+        collateralAmount,
+        options
+      );
+      const signature = await this.signOrder(order);
+      return await this.submitOrder(order, signature);
+    } catch (error) {
+      if (error instanceof DeploySDKError) throw error;
+      throw new DeploySDKError(
+        "REDEEM_FAILED" /* REDEEM_FAILED */,
+        "Failed to redeem tokens",
+        error
+      );
+    }
+  }
+  async estimateGas(token, redeemAmount, collateralAsset, collateralAmount, signature) {
+    const minterContract = new Contract4(
+      token.mintingContract,
+      MINTER_ABI,
+      this.sdk.provider
+    );
+    const order = {
+      order_id: uuidv42(),
+      order_type: 1,
+      expiry: Math.floor(Date.now() / 1e3) + 300,
+      nonce: Date.now(),
+      benefactor: await this.sdk.getAddress(),
+      beneficiary: await this.sdk.getAddress(),
+      collateral_asset: collateralAsset,
+      collateral_amount: collateralAmount.toString(),
+      dAsset_amount: redeemAmount.toString()
+    };
+    try {
+      const gasEstimate = await minterContract.estimateGas.redeem(
+        order,
+        { signature_type: 0, signature_bytes: signature }
+      );
+      return gasEstimate.toBigInt();
+    } catch (error) {
+      throw new DeploySDKError(
+        "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+        "Failed to estimate gas for redeem",
+        error
+      );
+    }
+  }
+};
+
+export {
+  ErrorCode,
+  DeploySDKError,
+  CONTRACT_ADDRESSES,
+  COLLATERAL_ASSETS,
+  STAKE_TOKENS,
+  EIP712_TYPES_ORDER,
+  ERC4626_ABI,
+  ERC20_ABI,
+  MINTER_ABI,
+  MintModule,
+  StakeModule,
+  UnstakeModule,
+  RedeemModule
+};