Wallet and signing

npm install @aomi-labs/client viem

import { Aomi, type EvmWallet } from "@aomi-labs/client";
import type {
  Hex,
  SignTypedDataParameters,
  WalletClient,
} from "viem";

function toAomiWallet(wallet: WalletClient): EvmWallet {
  const account = wallet.account;
  if (!account) throw new Error("Connect the wallet first");

  return {
    address: account.address,
    chainId: () => wallet.chain?.id,
    sendTransaction: ({ to, data, value }) =>
      wallet.sendTransaction({
        account,
        chain: wallet.chain,
        to: to as Hex,
        data: data as Hex | undefined,
        value: value === undefined ? undefined : BigInt(value),
      }),
    signMessage: ({ message }) =>
      wallet.signMessage({
        account,
        message: /^0x(?:[0-9a-fA-F]{2})*$/.test(message)
          ? { raw: message as Hex }
          : message,
      }),
    signTypedData: ({ typedData }) =>
      wallet.signTypedData({
        account,
        ...(typedData as Omit<SignTypedDataParameters, "account">),
      }),
    switchChain: (chainId) => wallet.switchChain({ id: chainId }),
  };
}

const aomi = new Aomi({
  baseUrl: process.env.AOMI_BASE_URL!,
  wallet: { evm: toAomiWallet(walletClient) },
});

const run = aomi.agent.run("Supply 100 USDC to Aave.");

run.on("action", async (action) => {
  if (action.state !== "pending") return;

  const approved = await showApprovalUI(action);

  if (!approved) {
    await run.reject(action.id, "User rejected");
    return;
  }

  if (!run.session.actions.canExecute(action.id)) {
    throw new Error(`No wallet capability can execute ${action.request.type}`);
  }

  await run.session.actions.execute(action.id);
});

await run.result();

import { commitCapabilities } from "@aomi-labs/client";

// wallets implements the required sign/broadcast or prepared-send methods.
// recoveryStore persists CommitRecoveryRecord values per thread and commit.
const run = aomi.agent.run("Prepare the transaction I requested.", {
  commits: commitCapabilities(wallets, recoveryStore),
});

const unsubscribe = run.session.subscribe(() => {
  for (const commit of run.session.getSnapshot().commits) {
    renderCommitReview(commit, run.session.commits.review(commit.commit_id));
  }
});

// Invoke these from explicit UI controls after displaying the latest review.
async function approveCommit(commitId: string) {
  const current = await run.session.commits.refresh(commitId);
  if (!run.session.commits.canExecute(current)) {
    throw new Error("Connect a wallet supporting this Commit action");
  }
  await run.session.commits.execute(commitId);
}

async function rejectCommit(commitId: string) {
  await run.session.commits.reject(commitId);
}

try {
  await run.result();
} finally {
  unsubscribe();
}

const build = await aomi.pipeline.evm.stage({
  chainId: 8453,
  calls: [{ to: contract, data: calldata, value: 0n }],
});

const simulated = await build.simulate();

renderReview({
  summary: simulated.summary,
  actions: simulated.actions,
  simulation: simulated.simulation,
});

if (await userApproved()) {
  const result = await simulated.commit();
  renderResult(result);
}