⚡EVM Actions

Execute transactions on EVM vaults including deposits, withdrawals, and approvals. All write operations are available via `sdk.evm.*` methods.

Overview

EVM write operations require a connected wallet with a signer. The SDK supports all vault versions (evm-0, evm-1, evm-2) and automatically selects the correct contract ABI and function signatures.

Setup

import { ethers } from 'ethers';
import { AugustSDK } from '@augustdigital/sdk';

// Initialize SDK
const sdk = new AugustSDK({
  providers: {
    1: 'https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY',
  },
});

// Connect wallet and set signer
const provider = new ethers.BrowserProvider(window.ethereum);
const signer = await provider.getSigner();
sdk.evm.setSigner(signer);

const userAddress = await signer.getAddress();

Vault Deposit

Deposit tokens into a vault. The SDK automatically handles different vault versions (evm-0, evm-1, evm-2) and adapter deposits.

sdk.evm.vaultDeposit({
  target: string;
  wallet: string;
  amount: string | bigint | number;
  wait?: boolean;
  depositAsset?: string;  // Optional: for adapter deposits
  chainId?: number;       // Optional: for adapter routing
  poolName?: string;      // Optional: for adapter routing
}): Promise<string>

Vault Version Detection

The SDK automatically detects the vault version and uses the correct deposit method:

Version
Deposit Function
Parameters
Use Case

evm-0

deposit(uint256, address)

2 params

Legacy vaults

evm-1

deposit(uint256, address)

2 params

Standard vaults

evm-2

deposit(address, uint256, address)

3 params

Multi-asset vaults

Adapter

Various

Depends on adapter type

Alternative token deposits

You don't need to specify the version - the SDK detects it automatically from the vault's version field.

Parameters

Parameter
Type
Required
Description

target

string

Yes

Vault contract address

wallet

string

Yes

User wallet address

amount

string | bigint | number

Yes

Amount to deposit

wait

boolean

No

Wait for confirmation (default: false)

depositAsset

string

No

Token to deposit (defaults to underlying)

chainId

number

No

Chain ID for adapter routing

poolName

string

No

Pool name for adapter routing

Returns

Transaction hash as string

Example: Standard Deposit

// Deposit underlying token
const txHash = await sdk.evm.vaultDeposit({
  target: '0x80E1048eDE66ec4c364b4F22C8768fc657FF6A42',
  wallet: userAddress,
  amount: '100', // 100 tokens
  wait: true,
});

console.log('Deposit successful:', txHash);

How It Works for Each Version

EVM-0 & EVM-1 Vaults (Standard)

Contract Function: deposit(uint256 assets, address receiver)

Behavior:

  • Deposits the vault's underlying token only

  • 2 parameters: amount and receiver

  • Automatic approval of underlying token to vault

Example:

// Upshift USDC (evm-1)
await sdk.evm.vaultDeposit({
  target: '0x80E1048eDE66ec4c364b4F22C8768fc657FF6A42',
  wallet: userAddress,
  amount: '100', // 100 USDC
  wait: true,
});
// SDK calls: vault.deposit(100e6, userAddress)

EVM-2 Vaults (Multi-Asset)

Contract Function: deposit(address assetIn, uint256 amount, address receiver)

Behavior:

  • Accepts multiple whitelisted tokens (listed in vault.depositAssets)

  • 3 parameters: asset address, amount, and receiver

  • Automatic approval of selected token to vault

Example:

// Get vault to see deposit options
const vault = await sdk.getVault({
  vault: '0x18EE038C114a07f4B08b420fb1E4149a4F357249',
  chainId: 1,
});

console.log('Can deposit:', vault.depositAssets.map(a => a.symbol));
// Output: ["USDC", "USDT", "DAI"]

// Deposit any whitelisted asset
await sdk.evm.vaultDeposit({
  target: vault.address,
  wallet: userAddress,
  amount: '100',
  depositAsset: '0xdAC17F958D2ee523a2206206994597C13D831ec7', // USDT
  chainId: 1,
  wait: true,
});
// SDK calls: vault.deposit(USDT_ADDRESS, 100e6, userAddress)

Note: For EVM-2 vaults, you can optionally specify depositAsset. If omitted, SDK uses the first asset in depositAssets array (usually the primary/underlying token).

Adapter Vaults (Alternative Tokens)

Contract Functions: Various depending on adapter type

Behavior:

  • Enables deposits with tokens beyond the vault's standard accepted tokens

  • Uses wrapper contracts or swap protocols

  • Requires depositAsset, chainId, and sometimes poolName parameters

Adapter Types:

  1. Native Token Adapter (e.g., ETH → wstETH)

    • Wraps native tokens before depositing

    • Uses WrapperAdapter contract

    • Example: Treehouse Growth

  2. Token Wrapper Adapter (e.g., WETH → wstETH)

    • Wraps ERC20 tokens before depositing

    • Uses WrapperAdapter contract

    • Example: Treehouse Growth

  3. Swap Adapter (e.g., USDC → WBTC)

    • Swaps tokens via Paraswap before depositing

    • Uses PoolAdapter contract

    • Example: BTC Multi-Token

Example: Native ETH Deposit

// Treehouse Growth accepts: wstETH, WETH, ETH (via adapter)
await sdk.evm.vaultDeposit({
  target: '0x5Fde59415625401278c4d41C6beFCe3790eb357f',
  wallet: userAddress,
  amount: '1.0', // 1 ETH
  depositAsset: '0x0000000000000000000000000000000000000000', // Native ETH
  chainId: 1,
  poolName: 'Treehouse Growth',
  wait: true,
});
// SDK calls: wrapperAdapter.depositETH() with value

Example: WETH Deposit (via adapter)

await sdk.evm.vaultDeposit({
  target: '0x5Fde59415625401278c4d41C6beFCe3790eb357f',
  wallet: userAddress,
  amount: '1.0',
  depositAsset: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', // WETH
  chainId: 1,
  poolName: 'Treehouse Growth',
  wait: true,
});
// SDK calls: wrapperAdapter.deposit() after approving WETH

Example: Swap Adapter Deposit

// BTC Multi-Token accepts WBTC but can swap from USDC
await sdk.evm.vaultDeposit({
  target: '0xBTCVaultAddress...',
  wallet: userAddress,
  amount: '10000', // 10,000 USDC
  depositAsset: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC
  chainId: 1,
  poolName: 'BTC Multi-Token',
  wait: true,
});
// SDK:
// 1. Gets Paraswap quote (USDC → WBTC)
// 2. Approves USDC to PoolAdapter
// 3. Calls: poolAdapter.swapAndDeposit()

Automatic Detection Flow

// Step 1: Get vault info
const vault = await sdk.getVault({ vault: vaultAddress, chainId: 1 });

// Step 2: SDK checks vault.version
if (vault.version === 'evm-2') {
  // Use 3-param deposit(address, uint256, address)
} else if (depositAsset && depositAsset !== vault.underlying.address) {
  // Use adapter logic
} else {
  // Use 2-param deposit(uint256, address)
}

// Step 3: SDK handles approvals automatically
// Step 4: SDK calls correct contract method

When to Use Each Parameter

Parameter
Required
Use When

target

✅ Always

Vault address

wallet

✅ Always

User's address

amount

✅ Always

Deposit amount

wait

❌ Optional

Want to wait for confirmation

depositAsset

⚠️ Sometimes

Using adapter OR EVM-2 with non-primary token

chainId

⚠️ Sometimes

Using adapter

poolName

⚠️ Sometimes

Using adapter (helps with routing)

Quick Reference: Vault Versions

How to check which version a vault uses:

const vault = await sdk.getVault({ vault: vaultAddress, chainId: 1 });
console.log('Version:', vault.version); // "evm-0", "evm-1", or "evm-2"
console.log('Has adapters:', vault.depositAssets.length > 1);

Common Vaults by Version:

Vault Name
Version
Deposit Tokens
Notes

Upshift USDC

evm-1

USDC only

Standard deposit

Upshift USDT

evm-1

USDT only

Standard deposit

Treehouse Growth

evm-1

wstETH, WETH, ETH

Has adapters

Kelp TAC rsETH

evm-1

rsETH, stETH, ETHx, WETH, ETH

Has adapters

Wild USD

evm-2

USDC, USDT, DAI

Multi-asset

BTC Multi-Token

evm-1

WBTC, USDC (via swap)

Has swap adapter

Decision Tree

Do you have a depositAsset parameter?
│
├─ NO → Standard deposit with underlying token
│        ├─ EVM-0/1: 2-param deposit
│        └─ EVM-2: 3-param deposit with first depositAsset
│
└─ YES → Is depositAsset different from underlying?
         │
         ├─ NO → Standard deposit (same as above)
         │
         └─ YES → Is vault EVM-2 with depositAsset whitelisted?
                  │
                  ├─ YES → Multi-asset deposit (3-param)
                  │
                  └─ NO → Adapter deposit
                           ├─ Native token? → Wrapper adapter
                           ├─ Different ERC20? → Swap adapter
                           └─ Wrapped version? → Wrapper adapter

Adapter Deposits

Deposit with alternative tokens beyond the vault's underlying asset.

Check Available Tokens

const vault = await sdk.getVault({ vault: vaultAddress, chainId: 1 });

console.log('Supported deposit tokens:');
vault.depositAssets.forEach(asset => {
  console.log(`- ${asset.symbol}: ${asset.address}`);
});

Deposit with Alternative Token

// Get vault info
const vault = await sdk.getVault({
  vault: '0x5Fde59415625401278c4d41C6beFCe3790eb357f', // Treehouse
  chainId: 1,
});

// Deposit WETH instead of wstETH
const txHash = await sdk.evm.vaultDeposit({
  target: vault.address,
  wallet: userAddress,
  amount: '1.0',
  depositAsset: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', // WETH
  chainId: 1,
  wait: true,
});

Deposit Native ETH

// Deposit native ETH (zero address)
await sdk.evm.vaultDeposit({
  target: '0x5Fde59415625401278c4d41C6beFCe3790eb357f',
  wallet: userAddress,
  amount: '1.0',
  depositAsset: '0x0000000000000000000000000000000000000000', // Native ETH
  chainId: 1,
  poolName: 'Treehouse Growth',
  wait: true,
});

Supported Adapter Vaults

Vault
Supported Tokens
Type

Treehouse Growth

wstETH, WETH, ETH

Native deposits

Kelp TAC rsETH

stETH, ETHx, WETH, ETH

Native deposits

BTC Multi-Token

WBTC, cbBTC, tBTC

Swap adapter (Paraswap)

AVAX Strategy

WAVAX, AVAX

Native deposits

Request Withdrawal

Request to withdraw tokens from a vault. Subject to lag period before claiming.

sdk.evm.vaultRequestRedeem({
  target: string;
  wallet: string;
  amount: string | bigint | number;
  wait?: boolean;
}): Promise<string>

Parameters

Parameter
Type
Required
Description

target

string

Yes

Vault contract address

wallet

string

Yes

User wallet address

amount

string | bigint | number

Yes

Amount of shares to redeem

wait

boolean

No

Wait for confirmation

Returns

Transaction hash as string

Example

// Request to redeem 50 vault shares
const txHash = await sdk.evm.vaultRequestRedeem({
  target: '0x80E1048eDE66ec4c364b4F22C8768fc657FF6A42',
  wallet: userAddress,
  amount: '50',
  wait: true,
});

console.log('Redemption requested:', txHash);
console.log('Wait for lag period before claiming');

// Check when you can claim
const { availableRedemptions } = await sdk.getVaultAvailableRedemptions({
  vault: '0x80E1048eDE66ec4c364b4F22C8768fc657FF6A42',
  wallet: userAddress,
  chainId: 1,
});

Behavior

The SDK automatically:

  1. Detects vault version

  2. Uses correct function signature:

    • EVM-0/1: requestRedeem(uint256, address, address) (3 params)

    • EVM-2: requestRedeem(uint256, address) (2 params)

  3. Converts amount to proper decimals

  4. Submits transaction

Claim Redemption

Claim tokens from a completed redemption request.

sdk.evm.vaultRedeem({
  target: string;
  wallet: string;
  wait?: boolean;
  year: string;
  month: string;
  day: string;
  receiverIndex: string;
}): Promise<string>

Parameters

Parameter
Type
Required
Description

target

string

Yes

Vault contract address

wallet

string

Yes

User wallet address

year

string

Yes

Year from redemption request

month

string

Yes

Month from redemption request

day

string

Yes

Day from redemption request

receiverIndex

string

Yes

Receiver index

wait

boolean

No

Wait for confirmation

Returns

Transaction hash as string

Example

// Get available redemptions
const { availableRedemptions } = await sdk.getVaultAvailableRedemptions({
  vault: vaultAddress,
  wallet: userAddress,
  chainId: 1,
});

// Claim first available redemption
if (availableRedemptions.length > 0) {
  const redemption = availableRedemptions[0];
  
  const txHash = await sdk.evm.vaultRedeem({
    target: vaultAddress,
    wallet: userAddress,
    year: redemption.year.raw,
    month: redemption.month.raw,
    day: redemption.day.raw,
    receiverIndex: '0',
    wait: true,
  });
  
  console.log('Claimed:', redemption.amount.normalized, 'tokens');
}

Token Approval

Approve vault to spend tokens. Usually called automatically by vaultDeposit.

sdk.evm.vaultApprove({
  target: string;
  wallet: string;
  amount: string | bigint | number;
  wait?: boolean;
}): Promise<string | undefined>

Returns

  • Transaction hash if approval was needed

  • undefined if allowance already sufficient

Example

// Manually approve before deposit
const txHash = await sdk.evm.vaultApprove({
  target: vaultAddress,
  wallet: userAddress,
  amount: '1000',
  wait: true,
});

if (txHash) {
  console.log('Approval tx:', txHash);
} else {
  console.log('Already approved');
}

Check Allowance

Check current token allowance for a vault.

sdk.evm.vaultAllowance({
  target: string;
  wallet: string;
}): Promise<INormalizedNumber>

Example

const allowance = await sdk.evm.vaultAllowance({
  target: vaultAddress,
  wallet: userAddress,
});

console.log('Current allowance:', allowance.normalized);

if (BigInt(allowance.raw) < BigInt(depositAmount)) {
  console.log('Need to approve more');
}

Examples

Complete Deposit Flow

// 1. Get vault and check options
const vault = await sdk.getVault({ vault: vaultAddress, chainId: 1 });

console.log('Deposit options:');
vault.depositAssets.forEach(asset => {
  console.log(`- ${asset.symbol}`);
});

// 2. Check if vault accepts deposits
if (vault.isDepositPaused) {
  throw new Error('Vault deposits are paused');
}

// 3. Check user balance
const tokenContract = new ethers.Contract(
  vault.depositAssets[0].address,
  ['function balanceOf(address) view returns (uint256)'],
  provider
);
const balance = await tokenContract.balanceOf(userAddress);

// 4. Deposit
const txHash = await sdk.evm.vaultDeposit({
  target: vault.address,
  wallet: userAddress,
  amount: '100',
  wait: true,
});

console.log('Success:', txHash);

Complete Withdrawal Flow

// 1. Check user position
const position = await sdk.getVaultPositions({
  vault: vaultAddress,
  wallet: userAddress,
  chainId: 1,
});

if (position[0].walletBalance.raw === '0') {
  throw new Error('No balance to withdraw');
}

// 2. Request redemption
const requestTx = await sdk.evm.vaultRequestRedeem({
  target: vaultAddress,
  wallet: userAddress,
  amount: '50',
  wait: true,
});

console.log('Redemption requested:', requestTx);

// 3. Wait for lag period...
await new Promise(resolve => setTimeout(resolve, vault.lagDuration * 1000));

// 4. Check if ready to claim
const { availableRedemptions } = await sdk.getVaultAvailableRedemptions({
  vault: vaultAddress,
  wallet: userAddress,
  chainId: 1,
});

// 5. Claim
if (availableRedemptions.length > 0) {
  const redemption = availableRedemptions[0];
  const claimTx = await sdk.evm.vaultRedeem({
    target: vaultAddress,
    wallet: userAddress,
    year: redemption.year.raw,
    month: redemption.month.raw,
    day: redemption.day.raw,
    receiverIndex: '0',
    wait: true,
  });
  
  console.log('Claimed:', claimTx);
}

Multi-Asset Vault Deposit

// Get EVM-2 vault
const vault = await sdk.getVault({
  vault: '0x18EE038C114a07f4B08b420fb1E4149a4F357249',
  chainId: 1,
});

console.log('Vault version:', vault.version); // "evm-2"
console.log('Deposit assets:', vault.depositAssets.length);

// Deposit any whitelisted asset
const selectedAsset = vault.depositAssets[0];

const txHash = await sdk.evm.vaultDeposit({
  target: vault.address,
  wallet: userAddress,
  amount: '100',
  depositAsset: selectedAsset.address, // Required for evm-2
  chainId: 1,
  wait: true,
});

Error Handling

try {
  await sdk.evm.vaultDeposit({
    target: vaultAddress,
    wallet: userAddress,
    amount: '100',
    wait: true,
  });
} catch (error) {
  if (error.message.includes('insufficient balance')) {
    console.error('Not enough tokens');
  } else if (error.message.includes('Deposit failed')) {
    console.error('Transaction reverted');
  } else if (error.message.includes('user rejected')) {
    console.error('User cancelled transaction');
  } else {
    console.error('Error:', error.message);
  }
}

Best Practices

1. Always Check Vault Status

const vault = await sdk.getVault({ vault, chainId });

if (vault.isDepositPaused) {
  throw new Error('Deposits are currently paused');
}

if (vault.isWithdrawalPaused) {
  throw new Error('Withdrawals are currently paused');
}

2. Verify Deposit Cap

const vault = await sdk.getVault({ vault, chainId });

const remaining = BigInt(vault.maxSupply.raw) - BigInt(vault.totalSupply.raw);
console.log('Remaining capacity:', ethers.formatUnits(remaining, vault.decimals));

3. Show User Expected Output

// For standard deposits, use previewDeposit
const vaultContract = new ethers.Contract(
  vaultAddress,
  ['function previewDeposit(uint256) view returns (uint256)'],
  provider
);

const expectedShares = await vaultContract.previewDeposit(
  ethers.parseUnits('100', vault.decimals)
);

console.log('You will receive:', ethers.formatUnits(expectedShares, vault.decimals), 'shares');
PreviousVaultsNextSolana Actions

Last updated