Yield via Osero Earn

import { SUPPORTED_CHAIN_IDS } from "@osero/client";

console.log(SUPPORTED_CHAIN_IDS);
// @osero/client@0.8.0: [1, 10, 130, 8453, 42161]

npm install @getpara/web-sdk @getpara/viem-v2-integration @osero/client viem

# ethers v6 adapter
npm install ethers

import { ParaWeb } from "@getpara/web-sdk";
import {
  createParaViemAccount,
  createParaViemClient,
} from "@getpara/viem-v2-integration";
import { OseroClient } from "@osero/client";
import { http } from "viem";
import { base } from "viem/chains";

const baseRpcUrl = "https://mainnet.base.org"; // Replace in production

const para = new ParaWeb("YOUR_PARA_API_KEY");

const client = OseroClient.create({
  transports: {
    8453: http(baseRpcUrl),
  },
  defaultSlippageBps: 10, // 0.10%; the SDK default is 5 bps
});

const account = createParaViemAccount({ para });

const walletClient = createParaViemClient({
  para,
  walletClientConfig: {
    account,
    chain: base,
    transport: http(baseRpcUrl),
  },
});

import { previewMintSUsds } from "@osero/client/actions";
import { formatUnits, parseUnits } from "viem";

const amount = parseUnits("100", 6); // 100 USDC

const quote = await previewMintSUsds(client, {
  chainId: 8453,
  amount,
});

if (quote.isErr()) {
  console.error("Could not quote mint:", quote.error.name, quote.error.message);
} else {
  console.log(
    `Expected output: approximately ${formatUnits(quote.value, 18)} sUSDS`,
  );
}

import { mintSUsds } from "@osero/client/actions";
import { sendWith } from "@osero/client/viem";

try {
  const result = await mintSUsds(client, {
    chainId: 8453,
    amount,
    sender: account.address,
  }).andThen(sendWith(walletClient));

  if (result.isErr()) {
    console.error(result.error.name, result.error.message);
  } else {
    console.log("sUSDS received in final tx", result.value.txHash);
  }
} catch (error) {
  // Covers documented synchronous/configuration failures and unexpected
  // rejected promises that do not become a ResultAsync Err value.
  console.error("Mint execution failed unexpectedly", error);
}

import type { Address } from "viem";

const custodyAddress: Address = "0x0000000000000000000000000000000000000001";

const result = await mintSUsds(client, {
  chainId: 8453,
  amount,
  sender: account.address,
  receiver: custodyAddress,
}).andThen(sendWith(walletClient));

import { redeemSUsds } from "@osero/client/actions";
import { getSUsdsBalance } from "@osero/client";

const balanceResult = await getSUsdsBalance(client, {
  chainId: 8453,
  account: account.address,
});

if (balanceResult.isErr()) {
  console.error(balanceResult.error.name, balanceResult.error.message);
} else {
  try {
    const redeemResult = await redeemSUsds(client, {
      chainId: 8453,
      amount: balanceResult.value, // sUSDS uses 18 decimals
      sender: account.address,
    }).andThen(sendWith(walletClient));

    if (redeemResult.isErr()) {
      console.error(redeemResult.error.name, redeemResult.error.message);
    } else {
      console.log("USDC received in final tx", redeemResult.value.txHash);
    }
  } catch (error) {
    console.error("Redeem execution failed unexpectedly", error);
  }
}

import { getSUsdsBalance, getTokenBalances } from "@osero/client";
import { formatUnits } from "viem";

const balances = await getTokenBalances(client, {
  chainId: 8453,
  account: account.address,
});

if (balances.isErr()) {
  console.error(balances.error.name, balances.error.message);
} else {
  console.log("USDC:", formatUnits(balances.value.USDC, 6));
  console.log("USDS:", formatUnits(balances.value.USDS, 18));
  console.log("sUSDS:", formatUnits(balances.value.sUSDS, 18));
}

const susds = await getSUsdsBalance(client, {
  chainId: 8453,
  account: account.address,
});

import type { Address } from "viem";
import { mintUsds } from "@osero/client/actions";
import { sendWith as sendWithViem } from "@osero/client/viem";
import { sendWith as sendWithEthers } from "@osero/client/ethers";

const requestFor = (sender: Address) => ({
  chainId: 8453,
  amount,
  sender,
});

// Para-backed viem wallet. The client must be configured for Base.
await mintUsds(client, requestFor(account.address)).andThen(
  sendWithViem(walletClient),
);

// ethers v6 signer. The signer must control ethersAddress and be connected
// to the target chain.
await mintUsds(client, requestFor(ethersAddress)).andThen(
  sendWithEthers(ethersSigner),
);

import { flattenExecutionPlan } from "@osero/client";

const planResult = await mintSUsds(client, {
  chainId: 8453,
  amount: parseUnits("100", 6),
  sender: account.address,
});

if (planResult.isErr()) {
  console.error(planResult.error.name, planResult.error.message);
} else {
  const transactions = flattenExecutionPlan(planResult.value);

  for (const transaction of transactions) {
    console.log("Chain:", transaction.chainId);
    console.log("Operation:", transaction.operation);
    console.log("From:", transaction.from);
    console.log("To:", transaction.to);
    console.log("Value:", transaction.value);
    console.log("Calldata:", transaction.data);
  }

  // No signer has been invoked yet.
}

const request = {
  chainId: 8453,
  amount,
  sender: account.address,
};

try {
  const result = await mintSUsds(client, request).andThen(
    sendWith(walletClient),
  );

  if (result.isErr()) {
    console.error(result.error.name, result.error.message);
    return;
  }

  console.log(result.value.txHash);
} catch (error) {
  console.error("Unexpected thrown or rejected failure", error);
}