Agent with a session key and a passkey

import { ChipiServerSDK } from "@chipi-stack/backend";
import type { SessionKeyData } from "@chipi-stack/types";

const sdk = new ChipiServerSDK({
  apiPublicKey: process.env.CHIPI_API_PUBLIC_KEY!,
  apiSecretKey: process.env.CHIPI_API_SECRET_KEY!,
});

export async function createAgentSession(
  userId: string,
  save: (userId: string, session: SessionKeyData) => Promise<void>
) {
  const session = sdk.sessions.createSessionKey({
    encryptKey: process.env.AGENT_SESSION_SECRET!,
    durationSeconds: 7 * 24 * 60 * 60, // 7 days
  });
  await save(userId, session);

  // Only the public part goes to the browser.
  return { sessionPublicKey: session.publicKey, validUntil: session.validUntil };
}

import { useAuth } from "@clerk/nextjs";
import { getWalletEncryptKey, useChipiSession, useChipiWallet } from "@chipi-stack/nextjs";

const USDC = "0x033068f6539f8e6e6b131e6b2b814e6c34a5224bc66947c47dab9dfee93b35fb";

export function HireAgent({ credentialId }: { credentialId: string }) {
  const { userId, getToken } = useAuth();
  const { wallet } = useChipiWallet({
    externalUserId: userId ?? null,
    getBearerToken: getToken,
  });

  const { registerSession, supportsSession, isRegistering } = useChipiSession({
    wallet,
    getEncryptKey: () => getWalletEncryptKey(credentialId),
    getBearerToken: () => getToken({ skipCache: true }),
  });

  const hire = async () => {
    const res = await fetch("/api/agent/session", { method: "POST" });
    const { sessionPublicKey, validUntil } = await res.json();

    await registerSession({
      sessionPublicKey,
      validUntil,
      maxCalls: 500,
      allowedEntrypoints: ["transfer", "approve", "multi_route_swap"],
      spendingPolicies: [
        // At most 5 USDC per call and 20 USDC per day.
        { token: USDC, maxPerCall: 5_000_000n, maxPerWindow: 20_000_000n, windowSeconds: 86_400 },
      ],
    });
  };

  if (!supportsSession) return <p>This wallet can't use an agent.</p>;
  return (
    <button onClick={hire} disabled={isRegistering}>
      Hire agent
    </button>
  );
}

import { ChipiServerSDK, isThinkDecision, waitForTransaction } from "@chipi-stack/backend";
import type { SessionKeyData } from "@chipi-stack/types";

const sdk = new ChipiServerSDK({
  apiPublicKey: process.env.CHIPI_API_PUBLIC_KEY!,
  apiSecretKey: process.env.CHIPI_API_SECRET_KEY!,
});

export async function tick(userId: string, session: SessionKeyData, maxTradeUsd: number) {
  const owner = await sdk.getWallet({ externalUserId: userId });
  if (!owner) throw new Error(`No wallet for ${userId}`);

  const { decision } = await sdk.ai.think({
    portfolio: { walletAddress: owner.publicKey },
    riskScore: 3,
  });

  // A non-JSON reply or an unknown action is not an order: hold.
  if (!isThinkDecision(decision) || decision.action !== "swap" || !decision.from || !decision.to) {
    return { action: "hold" as const };
  }

  // Your limits, not the model's.
  const amountUsd = Math.min(decision.amount ?? 0, maxTradeUsd);
  if (amountUsd <= 0) return { action: "hold" as const };

  const { calls } = await sdk.ai.execute({
    chain: "starknet",
    action: "swap",
    from: decision.from,
    to: decision.to,
    amountUsd,
    walletAddress: owner.publicKey,
    slippage: 0.01,
  });

  const txHash = await sdk.executeTransactionWithSession({
    params: {
      encryptKey: process.env.AGENT_SESSION_SECRET!,
      wallet: owner,
      session,
      calls,
    },
  });

  // A hash is not a result: read the receipt.
  const receipt = await waitForTransaction(txHash);
  return { action: "swap" as const, txHash, success: receipt.success };
}

import { SessionTxVerifier, type TxHashStore } from "@chipi-stack/backend";

const USDC = "0x033068f6539f8e6e6b131e6b2b814e6c34a5224bc66947c47dab9dfee93b35fb";

export function createPaymentCheck(store: TxHashStore, treasury: string) {
  // Back `store` with a unique index in your database in production.
  const verifier = new SessionTxVerifier({ txHashStore: store });

  return async (transactionHash: string, agentWallet: string) => {
    const result = await verifier.verifyTransfer({
      transactionHash,
      token: USDC,
      from: agentWallet,
      to: treasury,
      minAmount: 1_000n, // $0.001
    });
    return result.valid ? null : result.reason; // REVERTED, TRANSFER_NOT_FOUND, AMOUNT_TOO_LOW, ALREADY_USED
  };
}

import { useAuth } from "@clerk/nextjs";
import { getWalletEncryptKey, useChipiSession, useChipiWallet } from "@chipi-stack/nextjs";

export function StopAgent({ credentialId, sessionPublicKey }: { credentialId: string; sessionPublicKey: string }) {
  const { userId, getToken } = useAuth();
  const { wallet } = useChipiWallet({ externalUserId: userId ?? null, getBearerToken: getToken });
  const { revokeSession, isRevoking } = useChipiSession({
    wallet,
    getEncryptKey: () => getWalletEncryptKey(credentialId),
    getBearerToken: () => getToken({ skipCache: true }),
  });

  return (
    <button onClick={() => revokeSession(sessionPublicKey)} disabled={isRevoking}>
      Stop agent
    </button>
  );
}

import { ChipiServerSDK } from "@chipi-stack/backend";

const sdk = new ChipiServerSDK({
  apiPublicKey: process.env.CHIPI_API_PUBLIC_KEY!,
  apiSecretKey: process.env.CHIPI_API_SECRET_KEY!,
});

export async function sessionStatus(walletAddress: string, sessionPublicKey: string) {
  const data = await sdk.sessions.getSessionData({ walletAddress, sessionPublicKey });
  // isActive: registered, not expired and with calls left. remainingCalls: maxCalls - callsUsed.
  return { active: data.isActive, remainingCalls: data.remainingCalls, validUntil: data.validUntil };
}

import { buildSessionSetupCalls } from "@chipi-stack/backend";

const USDC = "0x033068f6539f8e6e6b131e6b2b814e6c34a5224bc66947c47dab9dfee93b35fb";

export function setupCalls(walletAddress: string, sessionPublicKey: string, validUntil: number) {
  // [add_or_update_session_key, set_spending_policy(USDC)]: one multicall, one signature.
  return buildSessionSetupCalls(
    walletAddress,
    { sessionPublicKey, validUntil, maxCalls: 500, allowedEntrypoints: ["transfer", "approve"] },
    [{ token: USDC, maxPerCall: 5_000_000n, maxPerWindow: 20_000_000n, windowSeconds: 86_400 }]
  );
}