Building on Yield.xyz with Turnkey

import { Turnkey } from "@turnkey/sdk-server";
import * as dotenv from "dotenv";
import * as path from "path";

// Load environment variables from `.env.local`
dotenv.config({ path: path.resolve(process.cwd(), ".env.local") });

async function main() {
  const turnkeyClient = new Turnkey({
    apiBaseUrl: "https://api.turnkey.com",
    apiPrivateKey: process.env.TURNKEY_API_PRIVATE_KEY!,
    apiPublicKey: process.env.TURNKEY_API_PUBLIC_KEY!,
    defaultOrganizationId: process.env.TURNKEY_ORGANIZATION_ID!,
  }).apiClient();

  // The id of the non-root user that you'll be using to sign the Yield related transactions
  const userId = process.env.NONROOT_USER_ID!;

  //approval policy
  const approvalPolicy = {
    policyName:
      "Allow API key user to call the approve function on the USDC_ADDRESS",
    effect: "EFFECT_ALLOW" as const,
    consensus: `approvers.any(user, user.id == '${userId}')`,
    condition: `eth.tx.to == '${process.env.USDC_ADDRESS}' && eth.tx.data[0..10] == '0x095ea7b3'`,
    notes: "",
  };

  const { policyId: approvalPolicyId } =
    await turnkeyClient.createPolicy(approvalPolicy);

  console.log(
    [
      `Created approval policy:`,
      `- Name: ${approvalPolicy.policyName}`,
      `- Policy ID: ${approvalPolicyId}`,
      `- Effect: ${approvalPolicy.effect}`,
      `- Consensus: ${approvalPolicy.consensus}`,
      `- Condition: ${approvalPolicy.condition}`,
      ``,
    ].join("\n"),
  );

  //deposit policy
  const depositPolicy = {
    policyName:
      "Allow API key user to call the deposit function on the gtUSDCf_VAULT_ADDRESS",
    effect: "EFFECT_ALLOW" as const,
    consensus: `approvers.any(user, user.id == '${userId}')`,
    condition: `eth.tx.to == '${process.env.gtUSDCf_VAULT_ADDRESS}' && eth.tx.data[0..10] == '0x6e553f65'`,
    notes: "",
  };

  const { policyId: depositPolicyId } =
    await turnkeyClient.createPolicy(depositPolicy);

  console.log(
    [
      `Created deposit policy:`,
      `- Name: ${depositPolicy.policyName}`,
      `- Policy ID: ${depositPolicyId}`,
      `- Effect: ${depositPolicy.effect}`,
      `- Consensus: ${depositPolicy.consensus}`,
      `- Condition: ${depositPolicy.condition}`,
      ``,
    ].join("\n"),
  );

  //withdraw policy
  const withdrawPolicy = {
    policyName:
      "Allow API key user to call the withdraw function on the gtUSDCf_VAULT_ADDRESS",
    effect: "EFFECT_ALLOW" as const,
    consensus: `approvers.any(user, user.id == '${userId}')`,
    condition: `eth.tx.to == '${process.env.gtUSDCf_VAULT_ADDRESS}' && eth.tx.data[0..10] == '0xba087652'`,
    notes: "",
  };

  const { policyId: withdrawPolicyId } =
    await turnkeyClient.createPolicy(withdrawPolicy);

  console.log(
    [
      `Created withdraw policy:`,
      `- Name: ${withdrawPolicy.policyName}`,
      `- Policy ID: ${withdrawPolicyId}`,
      `- Effect: ${withdrawPolicy.effect}`,
      `- Consensus: ${withdrawPolicy.consensus}`,
      `- Condition: ${withdrawPolicy.condition}`,
      ``,
    ].join("\n"),
  );
}

main().catch((error) => {
  console.error(error);
  process.exit(1);
});

const res = await fetch(
  'https://api.yield.xyz/v1/yields?network=base&token=USDC&limit=10',
  { headers: { 'X-API-KEY': process.env.YIELD_API_KEY! } }
);
const result = (await res.json()) as any; 
const items = result.items 

// pick one yield
const selected = items[0];
const YIELD_ID = selected.id;

// metadata is included in the object
const apy = selected.rewardRate;
const token = selected.token;
const metadata = selected.metadata;

import * as path from "path";
import * as dotenv from "dotenv";
import { ethers } from "ethers";
import { TurnkeySigner } from "@turnkey/ethers";
import { Turnkey as TurnkeyServerSDK } from "@turnkey/sdk-server";

// Load environment variables from `.env.local`
dotenv.config({ path: path.resolve(process.cwd(), ".env.local") });

async function main() {
  // Initialize the Turnkey client
  const turnkeyClient = new TurnkeyServerSDK({
    apiBaseUrl: "https://api.turnkey.com",
    apiPublicKey: process.env.NONROOT_API_PUBLIC_KEY!,
    apiPrivateKey: process.env.NONROOT_API_PRIVATE_KEY!,
    defaultOrganizationId: process.env.TURNKEY_ORGANIZATION_ID!,
  });

  // Initialize the Turnkey Signer
  const turnkeySigner = new TurnkeySigner({
    client: turnkeyClient.apiClient(),
    organizationId: process.env.TURNKEY_ORGANIZATION_ID!,
    signWith: process.env.SIGN_WITH!,
  });

  const provider = new ethers.JsonRpcProvider(process.env.RPC_URL!);
  const connectedSigner = turnkeySigner.connect(provider);

  // Prepare entry via Yield.xyz
  const depositAmount = "0.5";
  const enterPayload = {
    yieldId: process.env.YIELD_ID!, // e.g."base-usdc-gtusdcf-0x236919f11ff9ea9550a4287696c2fc9e18e6e890-4626-vault"
    address: process.env.SIGN_WITH!,
    arguments: { amount: depositAmount },
  };

  const enterRes = await fetch("https://api.yield.xyz/v1/actions/enter", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-key": process.env.YIELD_API_KEY!,
    },
    body: JSON.stringify(enterPayload),
  });
  const action = await enterRes.json();
  console.log("Yield API response:", JSON.stringify(action, null, 2));

  // Sign and broadcast each transaction step
  for (const tx of action.transactions) {
    const unsignedTx = JSON.parse(tx.unsignedTransaction);
    const sent = await connectedSigner.sendTransaction({
      to: unsignedTx.to,
      data: unsignedTx.data,
      value: unsignedTx.value ?? "0x0",
      chainId: unsignedTx.chainId,
    });
    console.log("Broadcasted tx:", sent.hash);
    await sent.wait(); //waiting for the approve transaction to be mined
  }
}

main().catch((err) => {
  console.error("Error running Yield deposit example:", err);
  process.exit(1);
});

const balanceRes = await fetch(
  `https://api.yield.xyz/v1/yields/${yieldId}/balances`,
  {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-key": process.env.YIELD_API_KEY!,
    },
    body: JSON.stringify({ address: turnkeyAccount.address }),
  }
);
const balances = await balanceRes.json();
console.log("Vault balances:", JSON.stringify(balances, null, 2));

const exitPayload = {
  yieldId: process.env.YIELD_ID! ,
  address: process.env.SIGN_WITH!,
  arguments: { amount: "0.1" },
};

const exitRes = await fetch("https://api.yield.xyz/v1/actions/exit", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-api-key": process.env.YIELD_API_KEY!,
  },
  body: JSON.stringify(exitPayload),
});
const exitAction = await exitRes.json();

for (const tx of exitAction.transactions) {
	const unsignedTx = JSON.parse(tx.unsignedTransaction);
  const sent = await connectedSigner.sendTransaction({
        to: unsignedTx.to,
        data: unsignedTx.data,
        value: unsignedTx.value ?? '0x0',
        chainId: unsignedTx.chainId
      });
  console.log("Withdraw tx:", sent.hash);
}