Give agents authority.
Not unlimited authority.

import { MandateClient } from "@0xgks/mandate-sdk";
import type { MandateClientConfig, PolicyParams, MandateOrder } from "@0xgks/mandate-sdk";

// Construct the client's config from environment variables.
// agentId is Poseidon2(session pk, salt) — the agent's on-chain identity.
const policy: PolicyParams = {
  whitelistRoot: BigInt(process.env.MANDATE_WHITELIST_ROOT!),
  maxOrderNotional: BigInt(process.env.MANDATE_MAX_ORDER_NOTIONAL!), // e.g. 1_000_000n
  maxPosition: BigInt(process.env.MANDATE_MAX_POSITION!),
  maxDailyLoss: BigInt(process.env.MANDATE_MAX_DAILY_LOSS!),
  policySalt: BigInt(process.env.MANDATE_POLICY_SALT!),
};

const config: MandateClientConfig = {
  agentId: process.env.MANDATE_AGENT_ID as `0x${string}`,
  sequencerUrl: process.env.MANDATE_SEQUENCER_URL ?? "http://127.0.0.1:8787",
  rpcUrl: process.env.MANDATE_RPC_URL ?? "http://127.0.0.1:8545",
  auctionAddress: process.env.MANDATE_AUCTION_ADDRESS as `0x${string}`,
  registryAddress: process.env.MANDATE_REGISTRY_ADDRESS as `0x${string}`,
  sessionPrivateKey: process.env.MANDATE_SESSION_KEY as `0x${string}`,
  policy,
  circuitDir: process.env.MANDATE_CIRCUIT_PATH ?? "./circuits/policy_check",
};

const mandate = new MandateClient(config);

// The order an agent/strategy hands to the SDK — human-friendly,
// string-encoded fields (see MandateOrder in types.ts).
const order: MandateOrder = {
  market: "1",        // circuit market id, as a decimal string
  side: "buy",
  amount: "250",       // whole circuit units, as a decimal string
  limitPrice: "3500",  // whole circuit units, as a decimal string
};

const result = await mandate.proveAndSubmit(order);
// result: { epoch, orderCommitment, proof, publicInputs, txHash }
console.log(`submitted in epoch ${result.epoch}: ${result.txHash}`);

import {
  MandateViolationError,
  PolicyMismatchError,
  PortfolioMismatchError,
  EpochClosedError,
} from "@0xgks/mandate-sdk";

try {
  await mandate.proveAndSubmit({
    market: "1",
    side: "buy",
    amount: "10000",     // 10,000 * 3,500 = 35,000,000 notional
    limitPrice: "3500",
  });
} catch (err) {
  if (err instanceof MandateViolationError) {
    // The order cannot be proven: nargo execute failed on a circuit
    // assertion (e.g. "order notional exceeds mandate maximum").
    // Nothing was submitted on-chain. err.reason is the bare circuit
    // assertion text; err.order is the rejected order.
    console.error(err.reason);
  } else if (err instanceof PolicyMismatchError) {
    // Local plaintext policy doesn't open the on-chain registered
    // commitment — refusing to prove with a stale or wrong mandate.
  } else if (err instanceof PortfolioMismatchError) {
    // Sequencer's reported state root disagrees with the on-chain
    // anchored root — refusing to prove against untrusted state.
  } else if (err instanceof EpochClosedError) {
    // The commit window closed while proving; not submitted.
  }
}