Stablecoin Yield via Upshift Vaults

Step 1 - approve the deposit asset (ERC-20)
Step 2 - call vaultDeposit()
         +--> shares are minted to the user's Para wallet in the same transaction

Step 1 - call vaultRequestRedeem(shares)
         +--> shares are escrowed by the vault
Step 2 - Upshift processes claimable redemptions daily
         +--> assets are released to the user according to the vault's withdrawal terms
Optional - instant redemption (isInstantRedeem: true) on vaults that support it

npm install @upshiftfinance/sdk @getpara/web-sdk @getpara/viem-v2-integration viem

import { ParaWeb } from "@getpara/web-sdk";
import {
  createParaViemAccount,
  createParaViemClient,
} from "@getpara/viem-v2-integration";
import UpshiftSDK from "@upshiftfinance/sdk";
import { http } from "viem";
import { mainnet } from "viem/chains";

const RPC_URL = "https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY";

const para = new ParaWeb("YOUR_PARA_API_KEY");

// Run your Para login flow before this point.
if (!(await para.isFullyLoggedIn())) {
  throw new Error("Log the user in with Para first");
}

const account = createParaViemAccount({ para });
const walletClient = createParaViemClient({
  para,
  walletClientConfig: { account, chain: mainnet, transport: http(RPC_URL) },
});

const sdk = new UpshiftSDK({
  appName: "your-app-name",
  providers: { 1: RPC_URL },
});

sdk.evm.setSigner(walletClient);
const owner = account.address;

const VAULT = "0x74aD2F789Ed583DBd141bbdafC673fE1F033718b"; // Sentora USD
const vault = await sdk.getVault({ vault: VAULT, chainId: 1 });

console.log(vault.name, vault.depositAssets, vault.totalAssets.normalized);

import { parseUnits, type Address } from "viem";

// Reuses `VAULT` and `vault` from Step 3
const asset = vault.depositAssets.find((a) => a.symbol === "USDC")!;
const assetAddress = asset.address as Address;
const amount = "100";

// 1. Cap and preview: both use raw units (100 USDC = 100_000_000n)
const cap = await sdk.evm.maxDeposit({ vault: VAULT, receiver: owner });
const shares = await sdk.evm.previewDeposit({
  vault: VAULT,
  amount: parseUnits(amount, asset.decimals),
  asset: assetAddress,
});

// 2. Approve if needed (human-readable amount)
const approval = await sdk.evm.approve({
  target: VAULT,
  wallet: owner,
  amount,
  depositAsset: assetAddress,
  wait: true,
});
if (approval.kind === "sent") console.log("approval tx", approval.hash);

// 3. Deposit (human-readable amount)
const txHash = await sdk.evm.vaultDeposit({
  target: VAULT,
  wallet: owner,
  amount,
  depositAsset: assetAddress,
  wait: true,
});

const positions = await sdk.getVaultPositions({ wallet: owner, chainId: 1 });

for (const p of positions) {
  console.log(p.vault, p.walletBalance.normalized, p.redeemable.normalized);
}

// Instant redemption is an opt-in alternative to the standard (queued) one,
// and only works on vaults that support it.
const supportsInstant =
  !!vault.instant_redeem_config && !vault.instant_redeem_config.isPaused;
const userChoseInstant = false; // from your UI

// amount is in shares
await sdk.evm.vaultRequestRedeem({
  target: VAULT,
  wallet: owner,
  amount: "50",
  isInstantRedeem: supportsInstant && userChoseInstant,
  wait: true,
});

// Track status
const { pendingRedemptions, availableRedemptions } =
  await sdk.getVaultAvailableRedemptions({
    vault: VAULT,
    chainId: 1,
    wallet: owner,
  });

import {
  UpshiftSDKError,
  UpshiftTimeoutError,
  UpshiftValidationError,
} from "@upshiftfinance/sdk";

try {
  await sdk.evm.vaultDeposit({ target: VAULT, wallet: owner, amount: "100" });
} catch (err) {
  if (err instanceof UpshiftValidationError) {
    console.error("Check the input:", err.message);
  } else if (err instanceof UpshiftTimeoutError) {
    // The deposit may already be onchain. Check the user's position before retrying.
    console.error(`Timed out after ${err.timeoutMs} ms`);
  } else if (err instanceof UpshiftSDKError) {
    console.error(err.code, err.cause);
  } else {
    throw err;
  }
}