Zama API

export YIELD_API_KEY=<your-api-key>
export ADDR=<your wallet EVM address>
export YIELD_ID=ethereum-usdc-zama-steakhouse-usdc-confidential-vault

type Intent = 'enter' | 'exit';
const same = (a: string, b: string) => a.toLowerCase() === b.toLowerCase();

function zamaContracts(yieldData: any, intent: Intent) {
  const fields: { name: string; options?: string[] }[] = yieldData.mechanics.arguments[intent].fields;
  const field = (name: string) => fields.find((f) => f.name === name);

  const legs = field('encryptedLegAmounts')?.options ?? [];
  const own = yieldData.executionContracts?.[intent] ?? [];
  const ownIndex = legs.findIndex((leg) => own.some((c: string) => same(c, leg)));

  const tokenAddresses = [...(yieldData.inputTokens ?? []), ...yieldData.tokens]
    .map((t: { address?: string }) => t.address)
    .filter(Boolean) as string[];
  const router = (yieldData.executionContracts?.enter ?? []).find(
    (c: string) => !legs.some((leg) => same(leg, c)) && !tokenAddresses.some((t) => same(t, c)),
  );

  return {
    legs,
    ownIndex,
    ownLeg: legs[ownIndex],
    router: router as `0x${string}`,
    amountContract: field('encryptedAmount')?.options?.[0] as `0x${string}`,
  };
}

import { createPublicClient, createWalletClient, custom, erc20Abi, http, parseAbi } from 'viem';
import { mainnet } from 'viem/chains';

const wrapperAbi = parseAbi([
  'function wrap(address to, uint256 amount) returns (bytes32)',
  'function rate() view returns (uint256)',
]);

const publicClient = createPublicClient({ chain: mainnet, transport: http(RPC_URL) });
const walletClient = createWalletClient({ chain: mainnet, transport: custom(window.ethereum) });
const [owner] = await walletClient.getAddresses();

async function wrapIntoConfidential(yieldData: any, amount: bigint): Promise<bigint> {
  const underlying = yieldData.token.address as `0x${string}`;
  const { amountContract: wrapper } = zamaContracts(yieldData, 'enter');

  const allowance = await publicClient.readContract({
    address: underlying, abi: erc20Abi, functionName: 'allowance', args: [owner, wrapper],
  });
  const send = async (hash: Promise<`0x${string}`>) =>
    publicClient.waitForTransactionReceipt({ hash: await hash });

  if (allowance < amount) {
    if (allowance > 0n) {
      await send(walletClient.writeContract({
        account: owner, address: underlying, abi: erc20Abi, functionName: 'approve', args: [wrapper, 0n],
      }));
    }
    await send(walletClient.writeContract({
      account: owner, address: underlying, abi: erc20Abi, functionName: 'approve', args: [wrapper, amount],
    }));
  }
  await send(walletClient.writeContract({
    account: owner, address: wrapper, abi: wrapperAbi, functionName: 'wrap', args: [owner, amount],
  }));

  const rate = await publicClient.readContract({ address: wrapper, abi: wrapperAbi, functionName: 'rate' });
  return amount / rate; // confidential token base units, the value to encrypt
}

import { BaseSigner, createConfig, memoryStorage, ZamaSDK, type EIP712TypedData } from '@zama-fhe/sdk';
import { chains, type FheChain } from '@zama-fhe/sdk/chains';
import { ViemProvider } from '@zama-fhe/sdk/viem';
import { web } from '@zama-fhe/sdk/web';

const CHAIN_ID = 1; // 11155111 for Ethereum Sepolia

class PermitSigner extends BaseSigner {
  signTypedData(typedData: EIP712TypedData) {
    // The SDK builds the domain chainId as a bigint. Wallets expect a number.
    const { domain, ...rest } = typedData;
    return walletClient.signTypedData({
      account: owner,
      ...rest,
      domain: { ...domain, ...(domain.chainId === undefined ? {} : { chainId: Number(domain.chainId) }) },
    } as Parameters<typeof walletClient.signTypedData>[0]);
  }
  writeContract(): Promise<`0x${string}`> {
    return Promise.reject(new Error('Send Zama transactions through the Yield.xyz API'));
  }
}

const chain = {
  ...chains[CHAIN_ID],
  auth: { __type: 'ApiKeyHeader', value: YIELD_API_KEY },
  relayerUrl: `https://api.yield.xyz/v1/zama/relayer/${CHAIN_ID}/`,
} satisfies FheChain;

const sdk = new ZamaSDK(
  createConfig({
    chains: [chain],
    provider: new ViemProvider({ publicClient }),
    relayers: { [chain.id]: web() },
    signer: new PermitSigner({ address: owner, chainId: CHAIN_ID }),
    storage: memoryStorage, // keeps keys and decrypted values in memory only
  }),
);

const { amountContract: cToken } = zamaContracts(yieldData, 'enter');
const confidentialBalance = await sdk.createToken(cToken).balanceOf(owner); // bigint, base units

async function encryptDeposit(yieldData: any, value: bigint) {
  const { legs, ownIndex, router, amountContract } = zamaContracts(yieldData, 'enter');

  const [amount, legBundle] = await Promise.all([
    sdk.encrypt({
      contractAddress: amountContract,
      userAddress: owner,
      values: [{ type: 'euint64', value }],
    }),
    sdk.encrypt({
      contractAddress: router,
      userAddress: owner,
      values: legs.map((_, index) => ({ type: 'euint64', value: index === ownIndex ? value : 0n })),
    }),
  ]);

  return {
    encryptedAmount: amount.encryptedValues[0],
    encryptedAmountProof: amount.inputProof,
    encryptedLegAmounts: legBundle.encryptedValues,
    encryptedLegProof: legBundle.inputProof,
  };
}

for (const tx of action.transactions.sort((a: any, b: any) => a.stepIndex - b.stepIndex)) {
  const hash = await signAndBroadcast(tx.unsignedTransaction);
  await fetch(`https://api.yield.xyz/v1/transactions/${tx.id}/submit-hash`, {
    method: 'PUT',
    headers: { 'x-api-key': YIELD_API_KEY, 'content-type': 'application/json' },
    body: JSON.stringify({ hash }),
  });
  await pollToTerminal(tx.id); // from Enter and exit flows
}

function handleContract(yieldData: any, balance: any): `0x${string}` {
  if (balance.type === 'entering') return zamaContracts(yieldData, 'enter').ownLeg as `0x${string}`;
  if (balance.type === 'exiting') return zamaContracts(yieldData, 'exit').ownLeg as `0x${string}`;
  return balance.shareToken.address;
}

const revealable = balances.filter((b: any) => b.isEncrypted && b.type !== 'withdrawable');
const clear = await sdk.decryption.decryptValues(
  revealable.map((b: any) => ({
    contractAddress: handleContract(yieldData, b),
    encryptedValue: b.shareAmountRaw,
  })),
);
// clear maps each handle to a bigint in base units. Compare handles in lowercase.

async function encryptPrivateExit(yieldData: any, shares: bigint) {
  const { legs, ownIndex, router } = zamaContracts(yieldData, 'exit');
  const bundle = await sdk.encrypt({
    contractAddress: router,
    userAddress: owner,
    values: legs.map((_, index) => ({ type: 'euint64', value: index === ownIndex ? shares : 0n })),
  });
  return { encryptedLegAmounts: bundle.encryptedValues, encryptedLegProof: bundle.inputProof };
}

const res = await fetch('https://api.yield.xyz/v1/actions/exit', {
  method: 'POST',
  headers: { 'x-api-key': YIELD_API_KEY, 'content-type': 'application/json' },
  body: JSON.stringify({
    yieldId: yieldData.id,
    address: owner,
    arguments: await encryptPrivateExit(yieldData, shares), // shares: revealed active balance or less
  }),
});

const { amountContract: shareToken } = zamaContracts(yieldData, 'exit');
const encrypted = await sdk.encrypt({
  contractAddress: shareToken,
  userAddress: owner,
  values: [{ type: 'euint64', value: shares }],
});

const res = await fetch('https://api.yield.xyz/v1/actions/exit', {
  method: 'POST',
  headers: { 'x-api-key': YIELD_API_KEY, 'content-type': 'application/json' },
  body: JSON.stringify({
    yieldId: yieldData.id,
    address: owner,
    arguments: {
      outputToken: yieldData.token.address,
      encryptedAmount: encrypted.encryptedValues[0],
      encryptedAmountProof: encrypted.inputProof,
    },
  }),
});

const row = balances.find((b: any) => b.type === 'withdrawable' && b.isEncrypted);
const pending = row.pendingActions.find((p: any) => p.type === 'WITHDRAW');

const handle = row.shareAmountRaw as `0x${string}`;
const { clearValues, decryptionProof } = await sdk.decryption.decryptPublicValues([handle]);
const cleartext = clearValues[handle];
if (typeof cleartext !== 'bigint') throw new Error('Public decrypt returned no value for this handle');

const res = await fetch('https://api.yield.xyz/v1/actions/manage', {
  method: 'POST',
  headers: { 'x-api-key': YIELD_API_KEY, 'content-type': 'application/json' },
  body: JSON.stringify({
    yieldId: yieldData.id,
    address: owner,
    action: 'WITHDRAW',
    passthrough: pending.passthrough,
    arguments: {
      decryptedAmount: cleartext.toString(), // uint64, base units
      decryptionProof,
    },
  }),
});