deploy-sdk 0.0.1

package/README.md

@@ -0,0 +1,317 @@
+# Deploy SDK
+
+Complete DeFi interaction library for the Deploy platform with support for mint, stake, unstake, and redeem operations.
+
+## Platform support
+
+The SDK works in **React (web)** and **React Native**. Same API in both; you only change how you obtain the wallet provider (browser: `window.ethereum` or Privy; React Native: WalletConnect, Privy React Native, or any EIP-1193 provider passed into `ExternalWalletAdapter`).
+
+## Installation
+
+```bash
+npm install deploy-sdk ethers
+```
+
+## Quick Start
+
+### 1. Initialize SDK with Privy
+
+```typescript
+import { DeploySDK, PrivyAdapter, COLLATERAL_ASSETS, STAKE_TOKENS } from 'deploy-sdk';
+import { usePrivy } from '@privy-io/react-auth';
+
+function App() {
+  const privy = usePrivy();
+  
+  const sdk = new DeploySDK({
+    apiUrl: 'https://your-api-url.com', // provide your backend API URL
+    chainId: 1, // Ethereum mainnet
+  });
+
+  const connectWallet = async () => {
+    const adapter = new PrivyAdapter(privy);
+    await sdk.initialize(adapter);
+    console.log('Connected:', await sdk.getAddress());
+  };
+}
+```
+
+### 2. Initialize SDK with MetaMask (React / browser)
+
+In the browser, use `window.ethereum` with `ExternalWalletAdapter`:
+
+```typescript
+import { DeploySDK, ExternalWalletAdapter } from 'deploy-sdk';
+
+const ethereum = window.ethereum;
+const adapter = new ExternalWalletAdapter(ethereum);
+
+const sdk = new DeploySDK({
+  apiUrl: 'https://your-api-url.com', // provide your backend API URL
+  chainId: 1,
+});
+
+await sdk.initialize(adapter);
+```
+
+### 3. Initialize SDK in React Native
+
+In React Native there is no `window.ethereum`. Get an EIP-1193 provider from your wallet stack (e.g. WalletConnect, Privy React Native) and pass it to `ExternalWalletAdapter`:
+
+```typescript
+import { DeploySDK, ExternalWalletAdapter } from 'deploy-sdk';
+
+// provider: from WalletConnect, Privy React Native, or your custom injector
+const adapter = new ExternalWalletAdapter(provider);
+const sdk = new DeploySDK({
+  apiUrl: 'https://your-api-url.com', // provide your backend API URL
+  chainId: 1,
+});
+
+await sdk.initialize(adapter);
+```
+
+### 4. Mint dUSD
+
+```typescript
+import { COLLATERAL_ASSETS } from 'deploy-sdk';
+
+const mintDUSD = async () => {
+  // Mint 1000 dUSD using USDC
+  const result = await sdk.mint.mint(
+    COLLATERAL_ASSETS.USDC,
+    '1000000000', // 1000 USDC (6 decimals)
+    '1000000000000000000000', // 1000 dUSD (18 decimals)
+    { expiryMinutes: 10 }
+  );
+  
+  console.log('Mint successful:', result.txHash);
+};
+```
+
+### 5. Stake dUSD
+
+```typescript
+import { STAKE_TOKENS } from 'deploy-sdk';
+
+const stakeDUSD = async () => {
+  // Stake 1000 dUSD
+  const result = await sdk.stake.stake({
+    token: STAKE_TOKENS.dUSD,
+    amount: '1000000000000000000000', // 1000 dUSD
+  });
+  
+  console.log('Staked:', result.sharesReceived, 'sDUSD shares');
+};
+```
+
+### 6. Unstake (with Cooldown)
+
+```typescript
+const unstakeProcess = async () => {
+  // Step 1: Initiate cooldown
+  const cooldownResult = await sdk.unstake.initiateCooldown(
+    STAKE_TOKENS.dUSD,
+    '500000000000000000000' // 500 sDUSD shares
+  );
+  
+  console.log('Cooldown initiated. Ends at:', new Date(cooldownResult.cooldownEnd!));
+  
+  // Step 2: Wait for cooldown to complete
+  // ... wait 90 days ...
+  
+  // Step 3: Unstake
+  const unstakeResult = await sdk.unstake.unstake({
+    token: STAKE_TOKENS.dUSD,
+    sharesAmount: '500000000000000000000',
+  });
+  
+  console.log('Unstaked:', unstakeResult.assetsWithdrawn, 'dUSD');
+};
+```
+
+### 7. Redeem dUSD for USDC
+
+```typescript
+const redeemDUSD = async () => {
+  const result = await sdk.redeem.redeem(
+    STAKE_TOKENS.dUSD,
+    '1000000000000000000000', // 1000 dUSD
+    COLLATERAL_ASSETS.USDC.address,
+    '1000000000', // 1000 USDC
+    { expiryMinutes: 10 }
+  );
+  
+  console.log('Redeem successful:', result.txHash);
+};
+```
+
+## SDK Events
+
+```typescript
+sdk.on('initialized', (data) => {
+  console.log('SDK initialized for address:', data.address);
+});
+
+sdk.on('error', (error) => {
+  console.error('SDK error:', error);
+});
+
+sdk.on('chainChanged', (data) => {
+  console.log('Chain changed to:', data.chainId);
+});
+
+sdk.on('disconnected', () => {
+  console.log('Wallet disconnected');
+});
+```
+
+## Utility Services
+
+### Allowance Management
+
+```typescript
+// Check allowance
+const allowance = await sdk.allowance.getAllowance(
+  COLLATERAL_ASSETS.USDC.address,
+  COLLATERAL_ASSETS.USDC.mintingContract
+);
+
+// Approve tokens
+await sdk.allowance.approve(
+  COLLATERAL_ASSETS.USDC.address,
+  COLLATERAL_ASSETS.USDC.mintingContract,
+  '1000000000'
+);
+
+// Approve max
+await sdk.allowance.approveMax(
+  COLLATERAL_ASSETS.USDC.address,
+  COLLATERAL_ASSETS.USDC.mintingContract
+);
+
+// Ensure allowance (approves if needed)
+await sdk.allowance.ensureAllowance(
+  COLLATERAL_ASSETS.USDC.address,
+  COLLATERAL_ASSETS.USDC.mintingContract,
+  '1000000000'
+);
+```
+
+### Balance Management
+
+```typescript
+// Get token balance
+const balance = await sdk.balances.getTokenBalance(
+  STAKE_TOKENS.dUSD.address
+);
+
+// Get native ETH balance
+const ethBalance = await sdk.balances.getNativeBalance();
+
+// Check sufficient balance
+const hasEnough = await sdk.balances.hasSufficientBalance(
+  STAKE_TOKENS.dUSD.address,
+  '1000000000000000000000'
+);
+```
+
+## Error Handling
+
+```typescript
+import { DeploySDKError, ErrorCode } from 'deploy-sdk';
+
+try {
+  await sdk.mint.mint(...);
+} catch (error) {
+  if (error instanceof DeploySDKError) {
+    console.log('Error code:', error.code);
+    console.log('Error message:', error.message);
+  
+    switch (error.code) {
+      case ErrorCode.INSUFFICIENT_BALANCE:
+        // Handle insufficient balance
+        break;
+      case ErrorCode.INSUFFICIENT_ALLOWANCE:
+        // Handle insufficient allowance
+        break;
+      case ErrorCode.SIGNATURE_FAILED:
+        // Handle signature failure
+        break;
+    }
+  }
+}
+```
+
+## API Reference
+
+### DeploySDK
+
+Main SDK class that provides access to all modules and services.
+
+**Constructor Options:**
+
+- `chainId`: Chain ID (default: 1)
+- `apiUrl`: Backend API URL
+- `rpcUrl`: Custom RPC URL
+
+### MintModule
+
+Handles minting dUSD using EIP-712 signed orders.
+
+**Methods:**
+
+- `createOrder()`: Create a mint order
+- `signOrder()`: Sign a mint order
+- `submitOrder()`: Submit signed order to backend
+- `mint()`: Full mint flow (create + sign + submit)
+- `estimateGas()`: Estimate gas for mint
+
+### StakeModule
+
+Handles ERC4626 vault staking operations.
+
+**Methods:**
+
+- `stake()`: Stake tokens into vault
+- `getPosition()`: Get user's staking position
+- `previewStake()`: Preview shares received for stake
+- `getAPY()`: Calculate current APY
+
+### UnstakeModule
+
+Handles ERC4626 vault unstaking with cooldown.
+
+**Methods:**
+
+- `initiateCooldown()`: Start cooldown period
+- `unstake()`: Unstake tokens after cooldown
+- `getCooldownStatus()`: Check cooldown status
+- `previewUnstake()`: Preview assets received for shares
+
+### RedeemModule
+
+Handles redeeming dUSD for collateral using EIP-712 signed orders.
+
+**Methods:**
+
+- `createOrder()`: Create a redeem order
+- `signOrder()`: Sign a redeem order
+- `submitOrder()`: Submit signed order to backend
+- `redeem()`: Full redeem flow (create + sign + submit)
+- `estimateGas()`: Estimate gas for redeem
+
+## Supported Tokens
+
+### Collateral Assets
+
+- **USDC**: USD Coin (6 decimals)
+- **USDT**: Tether USD (6 decimals)
+
+### Stake Tokens
+
+- **dUSD**: Deploy USD (stake to sDUSD)
+
+## License
+
+MIT

package/dist/base-01mNzZ7A.d.mts

@@ -0,0 +1,56 @@
+declare enum ChainId {
+    ETHEREUM = 1,
+    ARBITRUM = 42161
+}
+interface DeploySDKConfig {
+    chainId?: ChainId;
+    apiUrl?: string;
+    rpcUrl?: string;
+}
+interface SDKEvents {
+    initializing: () => void;
+    initialized: (data: {
+        address: string;
+    }) => void;
+    error: (error: any) => void;
+    chainChanged: (data: {
+        chainId: number;
+    }) => void;
+    disconnected: () => void;
+}
+interface CollateralAsset {
+    key: string;
+    name: string;
+    symbol: string;
+    address: string;
+    decimals: number;
+    mintingContract: string;
+}
+interface StakeToken {
+    key: string;
+    name: string;
+    symbol: string;
+    address: string;
+    decimals: number;
+    supportedCollateral: CollateralAsset[];
+    mintingContract: string;
+    stakingContract?: string;
+    stakingSymbol?: string;
+    cooldownPeriod?: number;
+}
+interface TransactionResult {
+    success: boolean;
+    txHash?: string;
+    error?: string;
+}
+
+interface WalletAdapter {
+    name: string;
+    getProvider(): Promise<any>;
+    getSigner(): Promise<any>;
+    isConnected(): Promise<boolean>;
+    switchChain?(chainId: ChainId): Promise<void>;
+    disconnect?(): Promise<void>;
+}
+
+export { type CollateralAsset as C, type DeploySDKConfig as D, type StakeToken as S, type TransactionResult as T, type WalletAdapter as W, ChainId as a, type SDKEvents as b };

package/dist/base-01mNzZ7A.d.ts

@@ -0,0 +1,56 @@
+declare enum ChainId {
+    ETHEREUM = 1,
+    ARBITRUM = 42161
+}
+interface DeploySDKConfig {
+    chainId?: ChainId;
+    apiUrl?: string;
+    rpcUrl?: string;
+}
+interface SDKEvents {
+    initializing: () => void;
+    initialized: (data: {
+        address: string;
+    }) => void;
+    error: (error: any) => void;
+    chainChanged: (data: {
+        chainId: number;
+    }) => void;
+    disconnected: () => void;
+}
+interface CollateralAsset {
+    key: string;
+    name: string;
+    symbol: string;
+    address: string;
+    decimals: number;
+    mintingContract: string;
+}
+interface StakeToken {
+    key: string;
+    name: string;
+    symbol: string;
+    address: string;
+    decimals: number;
+    supportedCollateral: CollateralAsset[];
+    mintingContract: string;
+    stakingContract?: string;
+    stakingSymbol?: string;
+    cooldownPeriod?: number;
+}
+interface TransactionResult {
+    success: boolean;
+    txHash?: string;
+    error?: string;
+}
+
+interface WalletAdapter {
+    name: string;
+    getProvider(): Promise<any>;
+    getSigner(): Promise<any>;
+    isConnected(): Promise<boolean>;
+    switchChain?(chainId: ChainId): Promise<void>;
+    disconnect?(): Promise<void>;
+}
+
+export { type CollateralAsset as C, type DeploySDKConfig as D, type StakeToken as S, type TransactionResult as T, type WalletAdapter as W, ChainId as a, type SDKEvents as b };

package/dist/base-DLLHDCZ5.d.mts

@@ -0,0 +1,56 @@
+declare enum ChainId {
+    ETHEREUM = 1,
+    ARBITRUM = 42161
+}
+interface DeploySDKConfig {
+    apiUrl: string;
+    chainId?: ChainId;
+    rpcUrl?: string;
+}
+interface SDKEvents {
+    initializing: () => void;
+    initialized: (data: {
+        address: string;
+    }) => void;
+    error: (error: any) => void;
+    chainChanged: (data: {
+        chainId: number;
+    }) => void;
+    disconnected: () => void;
+}
+interface CollateralAsset {
+    key: string;
+    name: string;
+    symbol: string;
+    address: string;
+    decimals: number;
+    mintingContract: string;
+}
+interface StakeToken {
+    key: string;
+    name: string;
+    symbol: string;
+    address: string;
+    decimals: number;
+    supportedCollateral: CollateralAsset[];
+    mintingContract: string;
+    stakingContract?: string;
+    stakingSymbol?: string;
+    cooldownPeriod?: number;
+}
+interface TransactionResult {
+    success: boolean;
+    txHash?: string;
+    error?: string;
+}
+
+interface WalletAdapter {
+    name: string;
+    getProvider(): Promise<any>;
+    getSigner(): Promise<any>;
+    isConnected(): Promise<boolean>;
+    switchChain?(chainId: ChainId): Promise<void>;
+    disconnect?(): Promise<void>;
+}
+
+export { type CollateralAsset as C, type DeploySDKConfig as D, type StakeToken as S, type TransactionResult as T, type WalletAdapter as W, ChainId as a, type SDKEvents as b };

package/dist/base-DLLHDCZ5.d.ts

@@ -0,0 +1,56 @@
+declare enum ChainId {
+    ETHEREUM = 1,
+    ARBITRUM = 42161
+}
+interface DeploySDKConfig {
+    apiUrl: string;
+    chainId?: ChainId;
+    rpcUrl?: string;
+}
+interface SDKEvents {
+    initializing: () => void;
+    initialized: (data: {
+        address: string;
+    }) => void;
+    error: (error: any) => void;
+    chainChanged: (data: {
+        chainId: number;
+    }) => void;
+    disconnected: () => void;
+}
+interface CollateralAsset {
+    key: string;
+    name: string;
+    symbol: string;
+    address: string;
+    decimals: number;
+    mintingContract: string;
+}
+interface StakeToken {
+    key: string;
+    name: string;
+    symbol: string;
+    address: string;
+    decimals: number;
+    supportedCollateral: CollateralAsset[];
+    mintingContract: string;
+    stakingContract?: string;
+    stakingSymbol?: string;
+    cooldownPeriod?: number;
+}
+interface TransactionResult {
+    success: boolean;
+    txHash?: string;
+    error?: string;
+}
+
+interface WalletAdapter {
+    name: string;
+    getProvider(): Promise<any>;
+    getSigner(): Promise<any>;
+    isConnected(): Promise<boolean>;
+    switchChain?(chainId: ChainId): Promise<void>;
+    disconnect?(): Promise<void>;
+}
+
+export { type CollateralAsset as C, type DeploySDKConfig as D, type StakeToken as S, type TransactionResult as T, type WalletAdapter as W, ChainId as a, type SDKEvents as b };

package/dist/chunk-ELR7YJ6L.mjs

@@ -0,0 +1,10 @@
+// src/core/types.ts
+var ChainId = /* @__PURE__ */ ((ChainId2) => {
+  ChainId2[ChainId2["ETHEREUM"] = 1] = "ETHEREUM";
+  ChainId2[ChainId2["ARBITRUM"] = 42161] = "ARBITRUM";
+  return ChainId2;
+})(ChainId || {});
+
+export {
+  ChainId
+};

package/dist/chunk-F2AHC5HC.mjs

@@ -0,0 +1,94 @@
+// src/wallet-adapters/privy-adapter.ts
+var PrivyAdapter = class {
+  constructor(privy) {
+    this.privy = privy;
+    this.name = "Privy";
+  }
+  async getProvider() {
+    return this.privy.getEthereumProvider();
+  }
+  async getSigner() {
+    const provider = await this.getProvider();
+    return provider.getSigner();
+  }
+  async isConnected() {
+    return !!this.privy.user?.wallet?.address;
+  }
+};
+
+// src/wallet-adapters/external-adapter.ts
+var ExternalWalletAdapter = class {
+  constructor(ethereum) {
+    this.ethereum = ethereum;
+    this.name = "External";
+  }
+  async getProvider() {
+    return this.ethereum;
+  }
+  async getSigner() {
+    await this.ethereum.request({ method: "eth_requestAccounts" });
+    return this.ethereum;
+  }
+  async isConnected() {
+    try {
+      const accounts = await this.ethereum.request({ method: "eth_accounts" });
+      return accounts.length > 0;
+    } catch {
+      return false;
+    }
+  }
+  async switchChain(chainId) {
+    const hexChainId = `0x${chainId.toString(16)}`;
+    try {
+      await this.ethereum.request({
+        method: "wallet_switchEthereumChain",
+        params: [{ chainId: hexChainId }]
+      });
+    } catch (switchError) {
+      if (switchError.code === 4902) {
+        await this.addChain(chainId);
+      } else {
+        throw switchError;
+      }
+    }
+  }
+  async addChain(chainId) {
+    const chainConfigs = {
+      [1 /* ETHEREUM */]: {
+        chainId: "0x1",
+        chainName: "Ethereum Mainnet",
+        nativeCurrency: {
+          name: "Ether",
+          symbol: "ETH",
+          decimals: 18
+        },
+        rpcUrls: ["https://eth.llamarpc.com"],
+        blockExplorerUrls: ["https://etherscan.io"]
+      },
+      [42161 /* ARBITRUM */]: {
+        chainId: "0xa4b1",
+        chainName: "Arbitrum One",
+        nativeCurrency: {
+          name: "Ether",
+          symbol: "ETH",
+          decimals: 18
+        },
+        rpcUrls: ["https://arb1.arbitrum.io/rpc"],
+        blockExplorerUrls: ["https://arbiscan.io"]
+      }
+    };
+    const config = chainConfigs[chainId];
+    if (!config) {
+      throw new Error(`Chain ${chainId} not supported`);
+    }
+    await this.ethereum.request({
+      method: "wallet_addEthereumChain",
+      params: [config]
+    });
+  }
+};
+
+export {
+  PrivyAdapter,
+  ExternalWalletAdapter
+};

package/dist/chunk-QZGD3DFS.mjs

@@ -0,0 +1 @@
+import{Contract as O}from"ethers";var w=(c=>(c.NOT_INITIALIZED="NOT_INITIALIZED",c.WALLET_NOT_CONNECTED="WALLET_NOT_CONNECTED",c.INVALID_CHAIN="INVALID_CHAIN",c.INSUFFICIENT_BALANCE="INSUFFICIENT_BALANCE",c.INSUFFICIENT_ALLOWANCE="INSUFFICIENT_ALLOWANCE",c.TRANSACTION_FAILED="TRANSACTION_FAILED",c.STAKE_FAILED="STAKE_FAILED",c.UNSTAKE_FAILED="UNSTAKE_FAILED",c.COOLDOWN_FAILED="COOLDOWN_FAILED",c.MINT_FAILED="MINT_FAILED",c.REDEEM_FAILED="REDEEM_FAILED",c.INVALID_ORDER="INVALID_ORDER",c.SIGNATURE_FAILED="SIGNATURE_FAILED",c.API_ERROR="API_ERROR",c.VALIDATION_ERROR="VALIDATION_ERROR",c))(w||{}),o=class g extends Error{constructor(t,r,e){super(r),this.name="DeploySDKError",this.code=t,this.originalError=e,Error.captureStackTrace&&Error.captureStackTrace(this,g)}toJSON(){return{name:this.name,code:this.code,message:this.message,originalError:this.originalError?.message||this.originalError}}};var m={1:{USDC:"0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",USDT:"0xdac17f958d2ee523a2206206994597c13d831ec7",dUSD:"0xf42e0b98e32150fe02a370456e6479fcd94f5531",DUSD_MINTER:"0x1ee453Ea35f6EAbD9BFF126586322cbC906D4EB3",sDUSD_STAKING:"0x7f37B0133B1adC1D0647EE52eA38fA13caC4aA1B"},42161:{}},_={USDC:{key:"USDC",name:"USD Coin",symbol:"USDC",address:m[1].USDC,decimals:6,mintingContract:m[1].DUSD_MINTER},USDT:{key:"USDT",name:"Tether USD",symbol:"USDT",address:m[1].USDT,decimals:6,mintingContract:m[1].DUSD_MINTER}},F={dUSD:{key:"dUSD",name:"Deploy USD",symbol:"dUSD",address:m[1].dUSD,decimals:18,supportedCollateral:[_.USDC,_.USDT],mintingContract:m[1].DUSD_MINTER,stakingContract:m[1].sDUSD_STAKING,stakingSymbol:"sDUSD",cooldownPeriod:2160*60*60*1e3}},h={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"}]},l=["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)"],P=["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)"],y=["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"];var R=class{constructor(t){this.sdk=t}async createOrder(t,r,e,n){let s=await this.sdk.getAddress(),a=crypto.randomUUID(),d=Math.floor(Date.now()/1e3)+(n?.expiryMinutes||5)*60,i=t.mintingContract;return{orderId:a,orderType:0,expiry:d,nonce:Date.now(),benefactor:n?.benefactor||s,beneficiary:n?.beneficiary||s,collateralAsset:t.address,collateralAmount:r.toString(),dAssetAmount:e.toString(),minterAddress:i}}async signOrder(t){let r=this.sdk.signer,e={name:"DeployMinting",version:"1",chainId:await this.sdk.getChainId(),verifyingContract:t.minterAddress},n={order_id:t.orderId,order_type:t.orderType,expiry:t.expiry,nonce:t.nonce,benefactor:t.benefactor,beneficiary:t.beneficiary,collateral_asset:t.collateralAsset,collateral_amount:t.collateralAmount,dAsset_amount:t.dAssetAmount};try{return await r._signTypedData(e,h,n)}catch(s){throw new o("SIGNATURE_FAILED","Failed to sign mint order",s)}}async submitOrder(t,r){try{let e=await fetch(`${this.sdk.config.apiUrl}/api/mint`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({order:{order_id:t.orderId,order_type:t.orderType,expiry:t.expiry,nonce:t.nonce,benefactor:t.benefactor,beneficiary:t.beneficiary,collateral_asset:t.collateralAsset,collateral_amount:t.collateralAmount,dAsset_amount:t.dAssetAmount},signature:{signature_type:0,signature_bytes:r}})});if(!e.ok){let s=await e.json();throw new o("API_ERROR",s.message||"Failed to submit mint order")}let n=await e.json();return{success:!0,orderId:t.orderId,txHash:n.txHash,status:n.status}}catch(e){throw e instanceof o?e:new o("API_ERROR","Failed to submit mint order",e)}}async mint(t,r,e,n){try{let s=await this.createOrder(t,r,e,n),a=await this.signOrder(s);return await this.submitOrder(s,a)}catch(s){throw s instanceof o?s:new o("MINT_FAILED","Failed to mint tokens",s)}}async estimateGas(t,r,e,n){let s=new O(t.mintingContract,y,this.sdk.provider),a={order_id:crypto.randomUUID(),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:t.address,collateral_amount:r.toString(),dAsset_amount:e.toString()};try{return(await s.estimateGas.mint(a,{addresses:[],ratios:[]},{signature_type:0,signature_bytes:n})).toBigInt()}catch(d){throw new o("TRANSACTION_FAILED","Failed to estimate gas for mint",d)}}};import{Contract as f,BigNumber as E}from"ethers";var S=class{constructor(t){this.sdk=t}async stake(t){try{let{token:r,amount:e,receiver:n}=t;if(!r.stakingContract)throw new o("VALIDATION_ERROR",`Token ${r.symbol} does not support staking`);let s=new f(r.stakingContract,l,this.sdk.signer),a=n||await this.sdk.getAddress(),i=await(await s.deposit(e,a)).wait(),u,p=i.events?.find(A=>A.event==="Deposit");return p&&(u=p.args?.shares?.toString()),{success:!0,txHash:i.transactionHash,sharesReceived:u}}catch(r){throw r instanceof o?r:new o("STAKE_FAILED","Failed to stake tokens",r)}}async getPosition(t,r){if(!t.stakingContract)throw new o("VALIDATION_ERROR",`Token ${t.symbol} does not support staking`);let e=r||await this.sdk.getAddress(),n=new f(t.stakingContract,l,this.sdk.provider);try{let[s,a,d]=await Promise.all([n.balanceOf(e),n.convertToAssets(await n.balanceOf(e)),n.cooldowns(e).catch(()=>({cooldownEnd:E.from(0),underlyingAmount:E.from(0)}))]),i=d.cooldownEnd.toNumber()*1e3;return{tokenKey:t.key,stakedAmount:s.toString(),stakedValue:a.toString(),cooldownEnd:i>0?i:void 0,canUnstake:i===0||i<=Date.now()}}catch(s){throw new o("VALIDATION_ERROR","Failed to fetch staking position",s)}}async previewStake(t,r){if(!t.stakingContract)throw new o("VALIDATION_ERROR",`Token ${t.symbol} does not support staking`);let e=new f(t.stakingContract,l,this.sdk.provider);try{return{shares:(await e.convertToShares(r)).toString(),assets:r.toString()}}catch(n){throw new o("VALIDATION_ERROR","Failed to preview stake",n)}}async getAPY(t){if(!t.stakingContract)return 0;let r=new f(t.stakingContract,l,this.sdk.provider);try{let[e,n]=await Promise.all([r.totalAssets(),r.totalSupply()]);if(n.isZero())return 0;let s=e.mul(E.from(10).pow(18)).div(n),a=E.from(10).pow(18);return s.lte(a)?0:s.sub(a).mul(365).mul(1e4).div(a).toNumber()/100}catch{return 0}}};import{Contract as D}from"ethers";var T=class{constructor(t){this.sdk=t}async initiateCooldown(t,r){try{if(!t.stakingContract)throw new o("VALIDATION_ERROR",`Token ${t.symbol} does not support staking`);let s=await(await new D(t.stakingContract,l,this.sdk.signer).cooldownShares(r)).wait(),a=Date.now()+(t.cooldownPeriod||2160*60*60*1e3);return{success:!0,txHash:s.transactionHash,cooldownEnd:a}}catch(e){throw e instanceof o?e:new o("COOLDOWN_FAILED","Failed to initiate cooldown",e)}}async unstake(t){try{let{token:r,sharesAmount:e,receiver:n}=t;if(!r.stakingContract)throw new o("VALIDATION_ERROR",`Token ${r.symbol} does not support staking`);let s=await this.getCooldownStatus(r);if(!s.canUnstake)throw new o("VALIDATION_ERROR",`Cannot unstake. Cooldown ends at ${new Date(s.cooldownEnd).toLocaleString()}`);let a=new D(r.stakingContract,l,this.sdk.signer),d=n||await this.sdk.getAddress(),i=await this.sdk.getAddress(),p=await(await a.redeem(e,d,i)).wait(),A,I=p.events?.find(b=>b.event==="Withdraw");return I&&(A=I.args?.assets?.toString()),{success:!0,txHash:p.transactionHash,assetsWithdrawn:A}}catch(r){throw r instanceof o?r:new o("UNSTAKE_FAILED","Failed to unstake tokens",r)}}async getCooldownStatus(t,r){if(!t.stakingContract)throw new o("VALIDATION_ERROR",`Token ${t.symbol} does not support staking`);let e=r||await this.sdk.getAddress(),n=new D(t.stakingContract,l,this.sdk.provider);try{let s=await n.cooldowns(e),a=s.cooldownEnd.toNumber()*1e3;return{cooldownEnd:a,sharesInCooldown:s.underlyingAmount.toString(),canUnstake:a>0&&a<=Date.now()}}catch(s){throw new o("VALIDATION_ERROR","Failed to fetch cooldown status",s)}}async previewUnstake(t,r){if(!t.stakingContract)throw new o("VALIDATION_ERROR",`Token ${t.symbol} does not support staking`);let e=new D(t.stakingContract,l,this.sdk.provider);try{return(await e.convertToAssets(r)).toString()}catch(n){throw new o("VALIDATION_ERROR","Failed to preview unstake",n)}}};import{Contract as N}from"ethers";var k=class{constructor(t){this.sdk=t}async createOrder(t,r,e,n,s){let a=await this.sdk.getAddress(),d=crypto.randomUUID(),i=Math.floor(Date.now()/1e3)+(s?.expiryMinutes||5)*60,u=t.mintingContract;return{orderId:d,orderType:1,expiry:i,nonce:Date.now(),benefactor:s?.benefactor||a,beneficiary:s?.beneficiary||a,collateralAsset:e,collateralAmount:n.toString(),dAssetAmount:r.toString(),minterAddress:u}}async signOrder(t){let r=this.sdk.signer,e={name:"DeployMinting",version:"1",chainId:await this.sdk.getChainId(),verifyingContract:t.minterAddress},n={order_id:t.orderId,order_type:t.orderType,expiry:t.expiry,nonce:t.nonce,benefactor:t.benefactor,beneficiary:t.beneficiary,collateral_asset:t.collateralAsset,collateral_amount:t.collateralAmount,dAsset_amount:t.dAssetAmount};try{return await r._signTypedData(e,h,n)}catch(s){throw new o("SIGNATURE_FAILED","Failed to sign redeem order",s)}}async submitOrder(t,r){try{let e=await fetch(`${this.sdk.config.apiUrl}/api/redeem`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({order:{order_id:t.orderId,order_type:t.orderType,expiry:t.expiry,nonce:t.nonce,benefactor:t.benefactor,beneficiary:t.beneficiary,collateral_asset:t.collateralAsset,collateral_amount:t.collateralAmount,dAsset_amount:t.dAssetAmount},signature:{signature_type:0,signature_bytes:r}})});if(!e.ok){let s=await e.json();throw new o("API_ERROR",s.message||"Failed to submit redeem order")}let n=await e.json();return{success:!0,orderId:t.orderId,txHash:n.txHash,status:n.status}}catch(e){throw e instanceof o?e:new o("API_ERROR","Failed to submit redeem order",e)}}async redeem(t,r,e,n,s){try{let a=await this.createOrder(t,r,e,n,s),d=await this.signOrder(a);return await this.submitOrder(a,d)}catch(a){throw a instanceof o?a:new o("REDEEM_FAILED","Failed to redeem tokens",a)}}async estimateGas(t,r,e,n,s){let a=new N(t.mintingContract,y,this.sdk.provider),d={order_id:crypto.randomUUID(),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:e,collateral_amount:n.toString(),dAsset_amount:r.toString()};try{return(await a.estimateGas.redeem(d,{signature_type:0,signature_bytes:s})).toBigInt()}catch(i){throw new o("TRANSACTION_FAILED","Failed to estimate gas for redeem",i)}}};export{w as a,o as b,m as c,_ as d,F as e,h as f,l as g,P as h,y as i,R as j,S as k,T as l,k as m};