Deploy SDK

Complete DeFi interaction library for the Deploy platform with support for mint, stake, unstake, and redeem operations.

Installation

npm install @deploy/sdk ethers viem

Quick Start

1. Initialize SDK with Privy

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://api.deploy.finance',
    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

import { DeploySDK, ExternalWalletAdapter } from '@deploy/sdk';

const ethereum = window.ethereum;
const adapter = new ExternalWalletAdapter(ethereum);

const sdk = new DeploySDK({
  apiUrl: 'https://api.deploy.finance',
  chainId: 1,
});

await sdk.initialize(adapter);

3. Mint dUSD

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);
};

4. Stake dUSD

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');
};

5. Unstake (with Cooldown)

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');
};

6. Redeem dUSD for USDC

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

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

// 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

// 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

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