@oakagentkit/addon 0.0.0-stage → 0.1.1

package/build/dist/cli.d.ts

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import { type OwnerSign } from './identity.js';
+import { type SetupRequest } from './setup.js';
+import type { Address } from 'viem';
+import { createBridge } from './bridge.js';
+import { SubscriptionLifecycle } from './subscribe.js';
+import { createWallet, exportKey } from './wallet.js';
+type Config = Record<string, string>;
+export declare function readConfig(path?: string): Promise<Config>;
+export declare function createRuntime(config: Config, writeDisplay: (text: string) => void | Promise<void>, recipeDirectory?: string, setupOptions?: {
+    configPath?: string;
+    signOwner?: OwnerSign;
+    terminalConfirmation?: boolean;
+}): Promise<{
+    wallet: `0x${string}`;
+    bridge: {
+        listTools: () => Promise<import("./bridge.js").ListedTool[]>;
+        postTool: (name: string, args: import("@oakagentkit/core/types").ToolArgs) => Promise<unknown>;
+        callTool: (name: string, original: import("@oakagentkit/core/types").ToolArgs) => Promise<unknown>;
+        start: (transport?: import("@modelcontextprotocol/sdk/shared/transport").Transport) => Promise<void>;
+        stop: () => Promise<void>;
+        confirmSignature: import("./confirm.js").Confirm;
+    };
+    readonly lifecycle: SubscriptionLifecycle;
+    subscribe: (plan: "holder" | "nohold") => Promise<import("./subscribe.js").LifecycleResult>;
+    cancel: () => Promise<import("./subscribe.js").LifecycleResult>;
+    renew: () => Promise<import("./subscribe.js").LifecycleResult>;
+    setup: (request: SetupRequest) => Promise<{
+        summary: string;
+        identity: import("@oakagentkit/core/identity-link").SessionIdentity;
+        hashes: string[];
+        status: string;
+    }>;
+    profile: import("@oakagentkit/core/types").ToolArgs | {
+        type: string;
+        name: string;
+        description: string;
+        image: string;
+        services: never[];
+        x402Support: boolean;
+        active: boolean;
+        registrations: never[];
+    };
+}>;
+type Runtime = Pick<Awaited<ReturnType<typeof createRuntime>>, 'wallet' | 'profile' | 'renew'> & {
+    bridge: Pick<ReturnType<typeof createBridge>, 'postTool' | 'callTool' | 'start'>;
+    lifecycle: Pick<SubscriptionLifecycle, 'subscribe' | 'cancel'>;
+    setup?: (request: SetupRequest) => Promise<unknown>;
+    subscribe?: (plan: 'holder' | 'nohold') => Promise<unknown>;
+    cancel?: () => Promise<unknown>;
+};
+export interface CliOptions {
+    output?: (text: string) => void;
+    error?: (text: string) => void;
+    isTTY?: boolean;
+    initialize?: typeof createWallet;
+    exportWallet?: typeof exportKey;
+    address?: () => Promise<Address>;
+    runtime?: () => Promise<Runtime>;
+    configPath?: string;
+    recipeDirectory?: string;
+    signOwner?: OwnerSign;
+    chooseSetup?: () => Promise<string>;
+}
+export declare function runCli(argv: string[], options?: CliOptions): Promise<number>;
+export declare function terminalOwnerSign(display: (text: string) => void): OwnerSign;
+export {};

package/build/dist/cli.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import{a as _e}from"./chunks/I5LKYO3W.js";import{a as he}from"./chunks/OB7JDPFV.js";import{e as F,f as ge}from"./chunks/UTTRLIY5.js";import{a as pe}from"./chunks/44YOYZLT.js";import{d as O,e as B,g as we}from"./chunks/RDCN3YPX.js";import{a as Q}from"./chunks/RGOGWTRI.js";import{d as ne,e as J,f as ie}from"./chunks/4LWKW7PM.js";import{c as oe}from"./chunks/U5VW3XSD.js";import{b as le,c as de,d as fe,e as ue}from"./chunks/VZCMAMZL.js";import{a as te,c as re,d as L}from"./chunks/GONTF7K4.js";import{a as $,b as Z,d as ee}from"./chunks/YVAFJM4Y.js";import"./chunks/IVR4JOHU.js";import"./chunks/U3IXRJH7.js";import"./chunks/2NJCYRBM.js";import{c as j,f as se,g as ae,i as ce}from"./chunks/YR4WKA4P.js";import"./chunks/4B2GMIK7.js";import"./chunks/QIDB35RS.js";import"./chunks/67E2KBUQ.js";import{buildIdentityLinkTypedData as Ke,canonicalSessionIdentity as Ee,identityNetwork as ye}from"@oakagentkit/core/identity-link";import{constants as k}from"node:fs";import{realpath as ke,rename as Ie,unlink as Ne}from"node:fs/promises";import{randomUUID as Pe}from"node:crypto";import{homedir as Ce}from"node:os";import{dirname as me,join as ve}from"node:path";import{pathToFileURL as Le}from"node:url";import{createPublicClient as Ue,getAddress as y,http as He}from"viem";import{ETH_USDG_POOL as xe,NETWORKS as I,assertNetworkRpc as We,assertNetworkUsdg as Oe,resolveNetwork as N}from"@oakagentkit/core/addresses";import{DEFAULT_RPC_URL as $e}from"@oakagentkit/core/chain";import{createWallet as Je,exportKey as je,loadSigner as Re}from"#oak-wallet";var Be="oak identity unlink [--owner <linkId>]|setup [register [--no-tag]|link <agentId>]|init [--recover [--replace]]|address|status|backup|export|subscribe --plan <holder|nohold>|renew|cancel|register [--no-tag]|recipes add|remove|list <pkg-or-path>|config set <k> <v>|mcp|call <tool> <json>",Se="The command or its arguments are not valid. Run oak --help and retry with the listed arguments.",Ae="as-is, not reviewed by Oak",U=()=>ve(Ce(),".oak","config.json"),Fe=new Set(["OAK_PRIVATE_TEST_MODE","OAK_LAUNCH_BOOTSTRAP","OAK_NETWORK","OAK_CHAIN_ID","OAK_SERVER_URL","OAK_RPC_URL","OAK_SUBSCRIPTION_ADDRESS","OAK_RETIRED_SUBSCRIPTION_ADDRESSES","OAK_TOKEN_ADDRESS","OAK_USDG_ADDRESS","OAK_ORACLE_ADDRESS","OAK_ETH_USDG_POOL_ADDRESS","OAK_FINALITY","profile","grandfather","identity","confirm"]);function G(n,i){if(!Fe.has(n)&&!/^OAK_RPC_URL_[1-9][0-9]*$/.test(n))throw new Error("Unknown setting. Wallet keys cannot be stored in config.");if(!i.trim()||i.length>1048576)throw new Error("Invalid configuration value.");if(["OAK_LAUNCH_BOOTSTRAP","OAK_PRIVATE_TEST_MODE"].includes(n)&&!["true","false"].includes(i))throw new Error("Set the mode to true or false.");if(n==="confirm"&&i!=="ask"&&i!=="auto")throw new Error("Set confirm to ask or auto.");if(n==="OAK_NETWORK")N(i);else{if(n==="OAK_CHAIN_ID"&&!["4663","46630"].includes(i))throw new Error("Set OAK_CHAIN_ID to 4663 or 46630.");if(n==="OAK_SERVER_URL")B(i);else if(n.startsWith("OAK_RPC_URL")){let o=new URL(i);if(!["https:","http:"].includes(o.protocol))throw new Error("RPC URL must use HTTP or HTTPS.")}else if(n.endsWith("_ADDRESS"))y(i);else if(n==="OAK_RETIRED_SUBSCRIPTION_ADDRESSES")i.split(",").forEach(o=>y(o.trim()));else{if(n==="OAK_FINALITY"&&i!=="safe"&&i!=="finalized"&&(!/^[1-9][0-9]*$/.test(i)||!Number.isSafeInteger(Number(i))))throw new Error("Invalid finality setting.");if(n==="identity"){let o=O(JSON.parse(i));Ee(o,ye(o.chainId))}else(n==="profile"||n==="grandfather")&&O(JSON.parse(i))}}}async function H(n=U()){let i;try{i=await L(n,k.O_RDONLY,2097152)}catch(o){if(o.code==="ENOENT")return{};throw ee()}try{let o=await i.stat();if(!o.isFile()||o.size>2097152)throw new Error("Invalid local Oak configuration.");let l=O(JSON.parse(await i.readFile("utf8")));for(let[p,s]of Object.entries(l)){if(typeof s!="string")throw new Error("Configuration values must be strings.");G(p,s)}return l}finally{await i.close()}}async function Y(n,i,o){if(o!==void 0)G(i,o);else if(i!=="identity")throw new Error("Only the public identity setting can be cleared.");let l={...await H(n)};o===void 0?delete l[i]:l[i]=o;let p=`${JSON.stringify(l,null,2)}
+`;if(Buffer.byteLength(p)>2097152)throw new Error("Local Oak configuration exceeds 2 MiB. Remove unused settings before retrying.");await te(me(n),!0);let s=`${n}.${Pe()}.tmp`,w=await L(s,k.O_WRONLY|k.O_CREAT|k.O_EXCL,2097152);try{try{await w.writeFile(p),await w.sync()}finally{await w.close()}try{await(await L(n,k.O_RDONLY,2097152)).close()}catch(r){if(r.code!=="ENOENT")throw r}await Ie(s,n),await re(me(n))}finally{await Ne(s).catch(r=>{if(r.code!=="ENOENT")throw r})}}async function Ye(n,i,o,l={}){n={...n};let p=t=>i($(t)),s=t=>process.env[t]??n[t],w=t=>{let c=s(t);if(!c)throw new Error(`Set ${t} with oak config set before this command.`);return c},r=N(n.OAK_NETWORK);if(process.env.OAK_NETWORK!==void 0&&N(process.env.OAK_NETWORK)!==r)throw new Error("OAK_NETWORK disagrees with the local config; set the network in the config explicitly.");let{chainId:e,usdg:S}=I[r];if((n.OAK_CHAIN_ID??String(I.mainnet.chainId))!==String(e)||process.env.OAK_CHAIN_ID!==void 0&&process.env.OAK_CHAIN_ID!==String(e))throw new Error(`Set OAK_CHAIN_ID to ${e} in the local deployment config.`);let g=(t,c)=>{let f=n[t]??c;if(!f)throw new Error(`Set ${t} in the local deployment config.`);let m=y(f);if(process.env[t]!==void 0&&y(process.env[t])!==m)throw new Error(`${t} disagrees with the local deployment config.`);return m},A=n.OAK_PRIVATE_TEST_MODE==="true",E=n.OAK_LAUNCH_BOOTSTRAP==="true";if(E&&A)throw new Error("Choose private test mode or launch-only bootstrap, then restart Oak.");if((E||A)&&r!=="mainnet")throw new Error("Launch bootstrap requires mainnet chain 4663.");let T=()=>{let t={network:r,chainId:e,subscription:g("OAK_SUBSCRIPTION_ADDRESS"),usdg:g("OAK_USDG_ADDRESS",S),oak:g("OAK_TOKEN_ADDRESS"),oracle:g("OAK_ORACLE_ADDRESS"),ethUsdgPool:g("OAK_ETH_USDG_POOL_ADDRESS")};return Oe(r,t.usdg),F(t),t},b=["OAK_SUBSCRIPTION_ADDRESS","OAK_TOKEN_ADDRESS","OAK_ORACLE_ADDRESS","OAK_ETH_USDG_POOL_ADDRESS"];for(let t of b)if(process.env[t]!==void 0&&n[t]===void 0)throw new Error(`Set ${t} in the local deployment config; environment-only addresses are not accepted.`);!E&&!A&&b.every(t=>n[t])&&T();let D=B(s("OAK_SERVER_URL")??(r==="mainnet"?"https://api.oakagentkit.org":w("OAK_SERVER_URL"))),d=async()=>{if(b.every(m=>n[m])){T();return}let t;try{let m=await fetch(new URL("/v1/config",D),{redirect:"error",signal:AbortSignal.timeout(5e3)}),K=O(await m.json());if(!m.ok||K.ok!==!0)throw new Error;t=O(K.data)}catch{throw new Error("Oak deployment configuration is unavailable. Ask the operator to enable /v1/config or configure the published Oak contract addresses. Your wallet address and read tools remain available.")}if(t.network!==r||t.chainId!==e||typeof t.usdg!="string")throw new Error("The Oak service configuration does not match the selected network.");Oe(r,y(t.usdg));let c={OAK_SUBSCRIPTION_ADDRESS:t.subscription,OAK_TOKEN_ADDRESS:t.oak,OAK_ORACLE_ADDRESS:t.oracle,OAK_ETH_USDG_POOL_ADDRESS:t.ethUsdgPool},f={};for(let[m,K]of Object.entries(c)){if(typeof K!="string")throw new Error("The Oak service deployment configuration is invalid.");let X=y(K);if(n[m]&&y(n[m])!==X)throw new Error(`${m} disagrees with the local deployment config.`);f[m]=X}if(F({network:r,chainId:e,subscription:f.OAK_SUBSCRIPTION_ADDRESS,oak:f.OAK_TOKEN_ADDRESS,oracle:f.OAK_ORACLE_ADDRESS,ethUsdgPool:f.OAK_ETH_USDG_POOL_ADDRESS,usdg:y(t.usdg)}),r==="mainnet"&&f.OAK_ETH_USDG_POOL_ADDRESS!==xe)throw new Error("ETH/USDG pool must match the pinned mainnet pool.");Object.assign(n,f),T()},u=new Map,a=t=>{let c=u.get(t);if(!c){let f=t===e?s("OAK_RPC_URL")??(r==="mainnet"?$e:w("OAK_RPC_URL")):w(`OAK_RPC_URL_${t}`);c=Ue({transport:He(f,{timeout:1e4,retryCount:0}),cacheTime:0}),u.set(t,c)}return c},h=[e,...Object.keys({...n,...process.env}).filter(t=>/^OAK_RPC_URL_[1-9][0-9]*$/.test(t)).map(t=>Number(t.slice(12)))];if(h.includes(r==="testnet"?I.mainnet.chainId:I.testnet.chainId))throw new Error("Do not configure the other Robinhood network as an additional RPC. Set OAK_NETWORK and OAK_RPC_URL together.");await Promise.all([...new Set(h)].filter(t=>t!==e||s("OAK_RPC_URL")).map(async t=>{let c=a(t);if(t===e)await We(r,c);else if(await c.getChainId()!==t)throw new Error(`RPC chain does not match configured chain ${t}.`)}));let _=s("OAK_FINALITY");_&&G("OAK_FINALITY",_);let P=_===void 0?void 0:_==="safe"||_==="finalized"?_:Number(_),R=await Re(),M=t=>{if(!t)return;let c=JSON.parse(t),f=Ee(c,ye(c.chainId));return f.chainId===e?f:void 0},x=ce({base:D,signer:R,network:r,identity:E||A?void 0:M(n.identity),clearIdentity:()=>Y(l.configPath??U(),"identity"),loadIdentity:async()=>E||A?void 0:M((await H(l.configPath)).identity)}),W=oe({signer:R,clientFor:a,allowedChainIds:h,finality:P,preview:p,confirm:l.terminalConfirmation?_e(n.confirm==="auto"?"auto":"ask"):t=>v.confirmSignature(t)}),Te={withAction:t=>W.withAction(c=>t({...c,send:async f=>(f.length&&await p(JSON.stringify(await v.postTool("preview",{txs:f}))),c.send(f))}))},be,C=()=>be??=new ge({wallet:R.address,deployment:T(),client:a(e),sender:Te,issueNote:async t=>{try{let c=await fetch(new URL("/v1/price-note",D),{method:"POST",redirect:"error",headers:{"content-type":"application/json"},body:JSON.stringify(t),signal:AbortSignal.timeout(3e4)}),f=await c.json();if(!c.ok&&!("reason"in f))throw new Error;return f}catch{throw new Error("Price note is unavailable. Retry when the server is reachable.")}},...n.grandfather?{grandfatherList:async()=>JSON.parse(n.grandfather)}:{}}),q=async()=>(await d(),he(C())),V=async t=>(await x.requireVerified(),await d(),C().subscribe(t)),De=async()=>(await d(),C().cancel()),v=we({oakTokenAddress:n.OAK_TOKEN_ADDRESS,confirmMode:n.confirm==="auto"?"auto":"ask",network:r,launchOnly:E,privateTestMode:A,identity:x,signOwner:l.signOwner,setup:t=>z(t),serverUrl:D.href,signer:R,sender:W,display:p,ensureSubscribed:q,startupInstructions:()=>le(R.address,r),subscribe:V,recipes:()=>J({directory:o}),recipeClient:a(e)}),z=pe({network:r,signer:{...R,signTypedData:t=>W.signTypedData(t)},identity:x,callTool:v.callTool,signOwner:l.signOwner,save:t=>Y(l.configPath??U(),"identity",JSON.stringify(t))});return{wallet:R.address,bridge:v,get lifecycle(){return C()},subscribe:V,cancel:De,renew:q,setup:z,profile:n.profile?O(JSON.parse(n.profile)):ue}}async function Ge(n,i={}){let o=i.output??(r=>{process.stdout.write(`${r}
+`)}),l=i.error??i.output??(r=>{process.stderr.write(`${r}
+`)}),p=r=>l($(r)),s=r=>o(JSON.stringify(r)),w=()=>{if(!(i.isTTY??(process.stdin.isTTY===!0&&process.stdout.isTTY===!0)))throw new Error("run this in your own terminal, not through the agent")};try{let[r,...e]=n;if(r==="--version"||r==="-v")return o(Q),0;if(r==="--help"||r==="-h")return o(Be),0;if(r==="init"&&(!e.length||e[0]==="--recover"&&(e.length===1||e.length===2&&e[1]==="--replace"))){w();let a=i.initialize??Je;return s(await(e.length?a({recover:!0,replace:e[1]==="--replace"}):a())),0}if(r==="export"&&!e.length)return w(),await(i.exportWallet??je)(),0;if(r==="backup"&&!e.length)return o(fe),0;if(r==="address"&&!e.length){let a=await H(i.configPath),h=N(a.OAK_NETWORK);if(process.env.OAK_NETWORK!==void 0&&N(process.env.OAK_NETWORK)!==h)throw new Error("OAK_NETWORK disagrees with the local config; set the network in the config explicitly.");let _=I[h].chainId;if(a.OAK_CHAIN_ID!==void 0&&a.OAK_CHAIN_ID!==String(_)||process.env.OAK_CHAIN_ID!==void 0&&process.env.OAK_CHAIN_ID!==String(_))throw new Error(`Set OAK_CHAIN_ID to ${_} for the selected network.`);return s(de(await(i.address??(async()=>(await Re()).address))(),h)),0}if(r==="config"&&e.length===3&&e[0]==="set")return e[1]==="confirm"&&e[2]==="auto"&&w(),await Y(i.configPath??U(),e[1],e[2]),o(`Saved ${e[1]}.`),0;if(r==="recipes"){let a={directory:i.recipeDirectory};if(e[0]==="add"&&e.length===2)s({recipes:await ne(e[1],a),label:Ae});else if(e[0]==="remove"&&e.length===2)await ie(e[1],a),o("Recipe project removed.");else if(e[0]==="list"&&e.length<=2)s({recipes:(await J(a)).filter(h=>!e[1]||h.project===e[1]),label:Ae});else throw new Error(Se);return 0}let S=r==="identity"&&e[0]==="unlink"&&(e.length===1||e.length===3&&e[1]==="--owner"&&/^0x[0-9a-f]{64}$/.test(e[2])),g=r==="setup"&&(!e.length||e[0]==="register"&&(e.length===1||e.length===2&&e[1]==="--no-tag")||e[0]==="link"&&e.length===2),A=["status","renew","cancel","mcp"].includes(r??"")&&!e.length,E=r==="subscribe"&&e.length===2&&e[0]==="--plan"&&["holder","nohold"].includes(e[1]),T=r==="register"&&(!e.length||e.length===1&&e[0]==="--no-tag"),b=r==="call"&&e.length===2;if(!S&&!g&&!A&&!E&&!T&&!b)throw new Error(Se);let D=b?O(JSON.parse(e[1])):void 0,d=await(i.runtime??(async()=>Ye(await H(i.configPath),p,i.recipeDirectory,{configPath:i.configPath,terminalConfirmation:r!=="mcp",signOwner:i.signOwner??(["setup","identity","mcp","call"].includes(r??"")?Me(p):void 0)})))(),u;switch(r){case"identity":u=await d.bridge.callTool("oak_identity_unlink",e[1]==="--owner"?{actor:"owner",linkId:e[2]}:{actor:"agent"});break;case"setup":{if(!d.setup)throw new Error("Identity setup is unavailable in this runtime.");let a=e[0],h=e[1];if(!a){let P=(i.chooseSetup?await i.chooseSetup():"register").trim().split(/\s+/);a=P[0],h=P[1]}if(a==="link"&&h)u=await d.setup({mode:a,agentId:h});else if(a==="register"){if(!d.profile)throw new Error("Set a registration-v1 profile with oak config set profile <json>, then run oak setup register.");u=await d.setup({mode:a,profile:d.profile,tag:h!=="--no-tag"})}else throw new Error("Choose register or link <agentId> with oak setup.");break}case"status":u={wallet:d.wallet,...O(await d.bridge.postTool("account",{}))};break;case"subscribe":u=await(d.subscribe??(a=>d.lifecycle.subscribe(a)))(e[1]);break;case"renew":u=await d.renew();break;case"cancel":u=await(d.cancel??(()=>d.lifecycle.cancel()))();break;case"register":if(!d.profile)throw new Error("Set a registration-v1 profile with oak config set profile <json>, then run oak register.");u=await d.bridge.callTool("erc8004_register",{profile:d.profile,tag:e[0]!=="--no-tag"});break;case"call":u=await d.bridge.callTool(e[0],D);break;case"mcp":return await d.bridge.start(),0}return s(u),u&&typeof u=="object"&&"ok"in u&&u.ok===!1?1:0}catch(r){return p(r instanceof SyntaxError?"The JSON is not valid. Use a JSON object with double-quoted field names and strings, then retry.":Z(r,"Oak command failed. Run oak status and retry when the server is reachable.")),1}}function Me(n){return async i=>{if(!process.stdin.isTTY||!process.stderr.isTTY)throw new Error(ae);return n("In the current owner\u2019s wallet, sign this EIP-712 identity request (the audience identifies link or unlink). Paste only the signature below; input is hidden. Never paste a key or recovery words."),n(JSON.stringify(Ke(i),(o,l)=>typeof l=="bigint"?l.toString():l)),new Promise((o,l)=>{let p=process.stdin.isRaw,s="",w=S=>{process.stdin.off("data",e),process.stdin.off("end",r),process.stdin.setRawMode(p===!0),process.stdin.pause(),S?l(S):/^0x(?:[0-9a-fA-F]{2})+$/.test(s)?o(s):l(new Error(j))},r=()=>w(new Error(se)),e=S=>{for(let g of S.toString("utf8")){if(g===""||g===""){r();return}if(g==="\r"||g===`
+`){w();return}if(g==="\x7F"?s=s.slice(0,-1):s+=g,s.length>131072){w(new Error(j));return}}};process.stdin.setRawMode(!0),process.stdin.on("data",e),process.stdin.once("end",r),process.stdin.resume()})}}process.argv[1]&&import.meta.url===Le(await ke(process.argv[1])).href&&(process.exitCode=await Ge(process.argv.slice(2)));export{Ye as createRuntime,H as readConfig,Ge as runCli,Me as terminalOwnerSign};

package/build/dist/confirm.d.ts

@@ -0,0 +1,120 @@
+import { type Address, type Hex, type PublicClient } from 'viem';
+import { type SwapQuote } from '@oakagentkit/core/swap';
+import type { Recipe, ToolArgs, TypedDataRequest, UnsignedTx } from '@oakagentkit/core/types';
+export declare const confirmationUnavailable = "Human confirmation is unavailable. Use an MCP client with form elicitation, or run oak config set confirm auto yourself in your own terminal. Restore confirmations with oak config set confirm ask.";
+export type ConfirmMode = 'ask' | 'auto';
+export interface ConfirmationRequest {
+    hash: Hex;
+    summary: string;
+}
+export type Confirm = (request: ConfirmationRequest) => Promise<void>;
+export interface Elicitor {
+    getClientCapabilities(): {
+        elicitation?: {
+            form?: unknown;
+            url?: unknown;
+        };
+    } | undefined;
+    elicitInput(params: {
+        mode: 'form';
+        message: string;
+        requestedSchema: {
+            type: 'object';
+            properties: {
+                confirm: {
+                    type: 'boolean';
+                    title: string;
+                    default: false;
+                };
+            };
+            required: string[];
+        };
+    }, options: {
+        timeout: number;
+    }): Promise<{
+        action: string;
+        content?: Record<string, unknown>;
+    }>;
+}
+export declare const CONFIRMATION_SECONDS = 300;
+export declare function createConfirmation(mode?: ConfirmMode, client?: () => Elicitor | undefined, timeout?: number): Confirm;
+export type SigningTransaction = {
+    chainId: number;
+    to: Address;
+    data: Hex;
+    value: bigint;
+    gas: bigint;
+    nonce: number;
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+};
+export declare function assertConfirmedBytes(rawTx: Hex, approved: SigningTransaction): void;
+export declare function confirmTransaction(confirm: Confirm, tx: SigningTransaction, summary: string): Promise<SigningTransaction>;
+export declare function snapshotTypedData(request: TypedDataRequest): TypedDataRequest;
+export declare function confirmTypedData(confirm: Confirm, request: TypedDataRequest, action?: Pick<ActionRequest, 'name'>): Promise<TypedDataRequest>;
+export declare function typedDataSummary(request: TypedDataRequest, action?: Pick<ActionRequest, 'name'>): string;
+export interface ActionRequest {
+    name: string;
+    args: ToolArgs;
+    quote?: SwapQuote;
+    quoteArgs?: ToolArgs;
+    chainId?: number;
+    oakTokenAddress?: Address;
+    recipe?: Recipe;
+    destinations?: Address[];
+}
+export interface AssetInput {
+    token: Address;
+    amount: bigint;
+    id?: bigint;
+}
+export interface Transfer {
+    token: Address;
+    from: Address;
+    to: Address;
+    amount: bigint;
+    id?: bigint;
+}
+export declare function decodeTransfers(calls: readonly {
+    logs?: unknown;
+}[], wallet: Address): Transfer[];
+export interface ApprovalChange {
+    token: Address;
+    spender: Address;
+    amount: bigint;
+    expiration?: number;
+    permit2?: Address;
+    kind?: 'permit';
+    nft?: true;
+}
+export declare const MAX_PERMIT2_LIFETIME: number;
+export declare function approvalDetails(tx: UnsignedTx, now?: number): ApprovalChange | undefined;
+export declare function decodeApprovals(calls: readonly {
+    logs?: unknown;
+}[], wallet: Address, now?: number): ApprovalChange[];
+export declare const allowanceKey: (change: Pick<ApprovalChange, "token" | "spender">) => string;
+type ApprovalCall = {
+    logs?: unknown;
+    status?: unknown;
+    returnData?: unknown;
+    data?: unknown;
+};
+export type AllowanceReader = (token: Address, spender: Address, blockNumber: bigint) => Promise<unknown>;
+export type AllowancePair = Pick<ApprovalChange, 'token' | 'spender'>;
+export type PostAllowanceSimulation = (index: number, pairs: readonly AllowancePair[]) => Promise<readonly ApprovalCall[]>;
+export declare function allowanceCall(pair: AllowancePair, wallet: Address): {
+    account: `0x${string}`;
+    to: `0x${string}`;
+    data: `0x${string}`;
+    value: bigint;
+    gas: bigint;
+};
+export declare function assertApprovalChanges(calls: readonly ApprovalCall[], wallet: Address, txs: UnsignedTx[], now?: number, preState?: ReadonlyMap<string, bigint>, postStates?: readonly ReadonlyMap<string, bigint>[], pins?: readonly Address[]): ApprovalChange[];
+export declare function verifyApprovalChanges(calls: readonly ApprovalCall[], wallet: Address, txs: UnsignedTx[], readAllowance: AllowanceReader, blockNumber: bigint, now?: number, simulatePostState?: PostAllowanceSimulation, pins?: readonly Address[]): Promise<ApprovalChange[]>;
+export declare function assertOutflows(transfers: Transfer[], wallet: Address, inputs: AssetInput[], spent?: Map<string, bigint>, txs?: UnsignedTx[]): Map<string, bigint>;
+export declare function assertModuleTransactions(txs: UnsignedTx[], action: ActionRequest): void;
+export declare function assertActionTransactions(txs: UnsignedTx[], action: ActionRequest, wallet: Address, inputs: AssetInput[]): void;
+export declare function summaryValue(value: string): string;
+export declare function transactionSummary(name: string, tx: SigningTransaction, transfers: Transfer[], wallet: Address, txs: UnsignedTx[], approvals?: ApprovalChange[]): string;
+export declare function actionInputs(action: ActionRequest, wallet: Address, client: Pick<PublicClient, 'readContract'>): Promise<AssetInput[]>;
+export {};

package/build/dist/confirm.js

@@ -0,0 +1 @@
+import{a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v}from"./chunks/U3IXRJH7.js";import"./chunks/67E2KBUQ.js";export{b as CONFIRMATION_SECONDS,j as MAX_PERMIT2_LIFETIME,v as actionInputs,n as allowanceCall,m as allowanceKey,k as approvalDetails,s as assertActionTransactions,o as assertApprovalChanges,d as assertConfirmedBytes,r as assertModuleTransactions,q as assertOutflows,e as confirmTransaction,g as confirmTypedData,a as confirmationUnavailable,c as createConfirmation,l as decodeApprovals,i as decodeTransfers,f as snapshotTypedData,t as summaryValue,u as transactionSummary,h as typedDataSummary,p as verifyApprovalChanges};

package/build/dist/execution-trace.d.ts

@@ -0,0 +1,30 @@
+import { type Address, type Hex } from 'viem';
+export interface TraceCall {
+    account: Address;
+    to: Address;
+    data: Hex;
+    value: bigint;
+    blockNumber?: bigint;
+    gas?: bigint;
+    nonce?: number;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+}
+export declare function assertExecutionTrace(result: unknown, call: TraceCall, pins: readonly Address[]): void;
+export declare function executionTraceRequest(call: TraceCall): {
+    method: string;
+    params: (string | {
+        maxPriorityFeePerGas?: `0x${string}` | undefined;
+        maxFeePerGas?: `0x${string}` | undefined;
+        nonce?: `0x${string}` | undefined;
+        gas?: `0x${string}` | undefined;
+        from: `0x${string}`;
+        to: `0x${string}`;
+        data: `0x${string}`;
+        value: `0x${string}`;
+        tracer?: undefined;
+    } | {
+        tracer: string;
+    })[];
+};
+export declare function createExecutionChecker(traceCall?: (call: TraceCall) => Promise<unknown>): (call: TraceCall, pins: readonly Address[], approvalToken?: Address) => Promise<"callTracer" | "simulation-only">;

package/build/dist/execution-trace.js

@@ -0,0 +1 @@
+import{a,b,c}from"./chunks/2NJCYRBM.js";export{a as assertExecutionTrace,c as createExecutionChecker,b as executionTraceRequest};

package/build/dist/identity.d.ts

@@ -0,0 +1,48 @@
+import { type SessionIdentity } from '@oakagentkit/core/identity-link';
+import type { IdentityLink, SignedIdentityLink } from '@oakagentkit/core/types';
+import type { OakNetwork } from '@oakagentkit/core/addresses';
+import type { WalletSigner } from './wallet.js';
+export declare const identityPaused = "Identity changed, expired or link revoked. Run oak setup link <agentId> with the current owner to verify or link it again. Reads remain available; actions are paused.";
+export declare const identityUnknown = "Identity status is unavailable. Please try again. Reads remain available; actions are paused.";
+export declare const ownerMismatch = "This wallet does not own that agent ID. Ask the current owner to sign the link in oak setup link <agentId>.";
+export declare const challengeExpired = "The identity challenge expired. Run oak setup link <agentId> again for a fresh owner signature.";
+export declare const wrongNetwork = "Wrong identity network or registry. Set OAK_NETWORK and OAK_CHAIN_ID to match the owner\u2019s agent, then run oak setup again.";
+export declare const signingCancelled = "Owner signing cancelled. Run the identity command again when ready.";
+export declare const signingUnavailable = "Owner signing requires your terminal. Run oak setup link <agentId> or oak identity unlink --owner <linkId> there.";
+export type UnlinkRequest = {
+    actor: 'agent' | 'owner';
+    linkId?: `0x${string}`;
+};
+export type OwnerSign = (link: IdentityLink) => Promise<SignedIdentityLink['signature']>;
+export declare function identityError(value: unknown): Error;
+export declare function createIdentityClient(options: {
+    base: URL;
+    signer: WalletSigner;
+    network: OakNetwork;
+    identity?: SessionIdentity;
+    fetch?: typeof fetch;
+    now?: () => number;
+    loadIdentity?: () => Promise<SessionIdentity | undefined>;
+    clearIdentity?: () => Promise<void>;
+}): {
+    sessions: {
+        readonly identity: {
+            chainId: number;
+            registry: import("viem").Address;
+            agentId: import("@oakagentkit/core/types").DecimalString;
+            linkId?: import("viem").Hex;
+        } | undefined;
+        setIdentity(value?: SessionIdentity): void;
+        clear: () => void;
+        get(): Promise<string>;
+        headers(method: string, path: string, body: string): Promise<Record<string, string>>;
+    };
+    requireVerified(): Promise<void>;
+    unlink(request?: UnlinkRequest, sign?: OwnerSign): Promise<{
+        unlinked: boolean;
+        summary: string;
+    }>;
+    accept(identity: SessionIdentity): Promise<SessionIdentity>;
+    link(identity: SessionIdentity, sign: OwnerSign): Promise<SessionIdentity>;
+};
+export type IdentityClient = ReturnType<typeof createIdentityClient>;

package/build/dist/identity.js

@@ -0,0 +1 @@
+import{a,b,c,d,e,f,g,h,i}from"./chunks/YR4WKA4P.js";import"./chunks/4B2GMIK7.js";export{d as challengeExpired,i as createIdentityClient,h as identityError,a as identityPaused,b as identityUnknown,c as ownerMismatch,f as signingCancelled,g as signingUnavailable,e as wrongNetwork};

package/build/dist/journal.d.ts

@@ -0,0 +1,53 @@
+import { type Address, type Hex } from 'viem';
+export interface JournalEntry {
+    nonce: number;
+    hash: Hex;
+    rawTx: Hex;
+    kind: 'approval' | 'main' | 'burn';
+    sentAt: number;
+    notAfter?: number;
+    chainId: number;
+    blockNumber: string;
+    previous?: Hex[];
+}
+export type ClearReason = 'nonce_consumed';
+export interface ClearedEntry {
+    hash: Hex;
+    nonce: number;
+    chainId: number;
+    kind: 'approval' | 'main' | 'burn';
+    sentAt: number;
+    blockNumber: string;
+    reason: ClearReason;
+    clearedAt: number;
+}
+export declare const walletDirectory: () => string;
+export declare const entryHashes: (entry: JournalEntry) => Hex[];
+export declare function withWalletLock<T>(address: Address, action: () => Promise<T>, options?: {
+    directory?: string;
+    pollMs?: number;
+    timeoutMs?: number;
+}): Promise<T>;
+export declare class Journal {
+    readonly address: Address;
+    readonly directory: string;
+    readonly path: string;
+    readonly clearedPath: string;
+    readonly approvalsPath: string;
+    constructor(address: Address, directory?: string);
+    private signedCall;
+    private validate;
+    private validateCleared;
+    private load;
+    private store;
+    approvals(): Promise<JournalEntry[]>;
+    retainApproval(entry: JournalEntry): Promise<void>;
+    forgetApproval(hash: Hex): Promise<void>;
+    read(): Promise<JournalEntry[]>;
+    cleared(): Promise<ClearedEntry[]>;
+    private write;
+    append(entry: JournalEntry): Promise<void>;
+    replace(hash: Hex, rawTx: Hex, blockNumber: string, sentAt: number): Promise<JournalEntry>;
+    burn(hash: Hex, rawTx: Hex, blockNumber: string, sentAt: number, notAfter?: number): Promise<JournalEntry>;
+    clear(hash: Hex, reason?: ClearReason): Promise<void>;
+}

package/build/dist/journal.js

@@ -0,0 +1 @@
+import{a,b,c,d}from"./chunks/QIDB35RS.js";export{d as Journal,b as entryHashes,a as walletDirectory,c as withWalletLock};

package/build/dist/module-destinations.d.ts

@@ -0,0 +1,4 @@
+import { type Address, type PublicClient } from 'viem';
+import type { ActionRequest } from './confirm.js';
+export declare function moduleDestinations(action: ActionRequest, chainId?: number): Address[];
+export declare function resolveModuleDestinations(action: ActionRequest, client: Pick<PublicClient, 'readContract'>, chainId?: number): Promise<Address[]>;

package/build/dist/module-destinations.js

@@ -0,0 +1 @@
+import{a,b}from"./chunks/67E2KBUQ.js";export{a as moduleDestinations,b as resolveModuleDestinations};

package/build/dist/onboarding.d.ts

@@ -0,0 +1,38 @@
+import { type Address } from 'viem';
+import { type OakNetwork } from '@oakagentkit/core/addresses';
+export declare function walletSummary(address: Address, network: OakNetwork): string;
+export declare function startupInstructions(address: Address, network: OakNetwork, directory?: string): Promise<string>;
+export declare function walletStatus(address: Address, network: OakNetwork): {
+    wallet: `0x${string}`;
+    address: `0x${string}`;
+    network: "testnet" | "mainnet";
+    chainId: 4663 | 46630;
+    funding: {
+        gas: {
+            address: string;
+            symbol: string;
+            decimals: number;
+            chainId: 4663 | 46630;
+        };
+        payment: {
+            address: `0x${string}`;
+            symbol: string;
+            decimals: number;
+            chainId: 4663 | 46630;
+        };
+    };
+    message: string;
+    backup: string;
+    notice: string;
+};
+export declare const backupGuidance = "Backups are optional. When you hold more than pocket change, run oak export in your own terminal, never through an agent. Keep the exported private key offline and private. Restore it with oak init --recover in your own terminal. Automatic wallets have no recovery phrase. Oak cannot recover a lost key.";
+export declare const defaultProfile: {
+    type: string;
+    name: string;
+    description: string;
+    image: string;
+    services: never[];
+    x402Support: boolean;
+    active: boolean;
+    registrations: never[];
+};

package/build/dist/onboarding.js

@@ -0,0 +1 @@
+import{a,b,c,d,e}from"./chunks/VZCMAMZL.js";import"./chunks/GONTF7K4.js";export{d as backupGuidance,e as defaultProfile,b as startupInstructions,c as walletStatus,a as walletSummary};

package/build/dist/private-files.d.ts

@@ -0,0 +1,5 @@
+import { type FileHandle } from 'node:fs/promises';
+export declare function privateDirectory(path: string, create?: boolean): Promise<void>;
+export declare function privateFile(handle: FileHandle, maximum: number): Promise<void>;
+export declare function syncPrivateDirectory(path: string): Promise<void>;
+export declare function openPrivateFile(path: string, flags: number, maximum: number, createDirectory?: boolean): Promise<FileHandle>;

package/build/dist/private-files.js

@@ -0,0 +1 @@
+import{a,b,c,d}from"./chunks/GONTF7K4.js";export{d as openPrivateFile,a as privateDirectory,b as privateFile,c as syncPrivateDirectory};

package/build/dist/recipes.d.ts

@@ -0,0 +1,26 @@
+import { type Address, type Hex } from 'viem';
+import type { JsonValue, Recipe, UnsignedTx } from '@oakagentkit/core/types';
+export declare function loadRecipe(json: unknown): Recipe;
+export type DecodedResult = JsonValue;
+export interface RecipeReadClient {
+    getChainId(): Promise<number>;
+    call(args: {
+        to: Address;
+        data: Hex;
+    }): Promise<{
+        data?: Hex;
+    }>;
+}
+export declare function buildRead(recipe: Recipe, args: Record<string, unknown>, options?: {
+    client?: RecipeReadClient;
+}): Promise<DecodedResult>;
+export declare function buildTx(recipe: Recipe, args: Record<string, unknown>, wallet: Address): UnsignedTx[];
+export interface RecipeStoreOptions {
+    directory?: string;
+}
+export interface RecipeImportOptions extends RecipeStoreOptions {
+    fetch?: typeof fetch;
+}
+export declare function addRecipes(source: string, options?: RecipeImportOptions): Promise<Recipe[]>;
+export declare function listRecipes(options?: RecipeStoreOptions): Promise<Recipe[]>;
+export declare function removeRecipes(project: string, options?: RecipeStoreOptions): Promise<void>;

package/build/dist/recipes.js

@@ -0,0 +1 @@
+import{a,b,c,d,e,f}from"./chunks/4LWKW7PM.js";import"./chunks/GONTF7K4.js";import"./chunks/YVAFJM4Y.js";export{d as addRecipes,b as buildRead,c as buildTx,e as listRecipes,a as loadRecipe,f as removeRecipes};

package/build/dist/redact.d.ts

@@ -0,0 +1,4 @@
+export declare function redact(text: string): string;
+export declare function errorMessage(error: unknown, fallback?: string): string;
+export declare const publicError: (error: unknown) => Error;
+export declare const configReadError: () => Error;

package/build/dist/redact.js

@@ -0,0 +1 @@
+import{a,b,c,d}from"./chunks/YVAFJM4Y.js";export{d as configReadError,b as errorMessage,c as publicError,a as redact};

package/build/dist/renew.d.ts

@@ -0,0 +1,2 @@
+import { SubscriptionLifecycle, type LifecycleResult } from './subscribe.js';
+export declare function ensureSubscribed(lifecycle: SubscriptionLifecycle): Promise<LifecycleResult>;

package/build/dist/renew.js

@@ -0,0 +1 @@
+import{a}from"./chunks/OB7JDPFV.js";import"./chunks/UTTRLIY5.js";import"./chunks/U5VW3XSD.js";import"./chunks/YVAFJM4Y.js";import"./chunks/IVR4JOHU.js";import"./chunks/U3IXRJH7.js";import"./chunks/2NJCYRBM.js";import"./chunks/QIDB35RS.js";import"./chunks/67E2KBUQ.js";export{a as ensureSubscribed};

package/build/dist/schema/recipe.schema.json

@@ -0,0 +1 @@
+{"$schema":"http://json-schema.org/draft-07/schema#","$id":"https://oakagentkit.org/schema/recipe.schema.json","title":"Oak declarative recipe v1","type":"object","additionalProperties":false,"required":["schema","project","name","description","chainId","contract","function","inputs","kind"],"properties":{"schema":{"const":"oak-recipe/v1"},"project":{"$ref":"#/definitions/slug"},"name":{"$ref":"#/definitions/slug"},"description":{"type":"string"},"chainId":{"const":4663},"contract":{"type":"string","format":"eip55"},"function":{"type":"object","additionalProperties":false,"required":["type","name","stateMutability","inputs","outputs"],"properties":{"type":{"const":"function"},"name":{"type":"string","pattern":"^[A-Za-z_][A-Za-z0-9_]*$"},"stateMutability":{"enum":["view","pure","nonpayable","payable"]},"inputs":{"type":"array","maxItems":128,"items":{"$ref":"#/definitions/parameter"}},"outputs":{"type":"array","maxItems":128,"items":{"$ref":"#/definitions/parameter"}}}},"inputs":{"type":"array","maxItems":128,"items":{"type":"object","additionalProperties":false,"required":["name","type","description"],"properties":{"name":{"type":"string","pattern":"^[A-Za-z_][A-Za-z0-9_]*$"},"type":{"type":"string","pattern":"^(address|bool|string|bytes([1-9]|[12][0-9]|3[0-2])?|u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?|tuple)(\\[([1-9][0-9]*)?\\])*$"},"description":{"type":"string"},"default":{}}}},"kind":{"enum":["read","tx"]},"value":{"type":"object","additionalProperties":false,"required":["fromInput"],"properties":{"fromInput":{"type":"string","pattern":"^[A-Za-z_][A-Za-z0-9_]*$"}}},"approve":{"type":"object","additionalProperties":false,"required":["token","amountFromInput"],"properties":{"token":{"type":"string","format":"eip55"},"amountFromInput":{"type":"string","pattern":"^[A-Za-z_][A-Za-z0-9_]*$"}}}},"definitions":{"slug":{"type":"string","pattern":"^[a-z0-9-]{1,40}$"},"parameter":{"type":"object","additionalProperties":false,"required":["type"],"properties":{"name":{"type":"string","pattern":"^([A-Za-z_][A-Za-z0-9_]*)?$"},"type":{"type":"string","pattern":"^(address|bool|string|bytes([1-9]|[12][0-9]|3[0-2])?|u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?|tuple)(\\[([1-9][0-9]*)?\\])*$"},"internalType":{"type":"string"},"components":{"type":"array","minItems":1,"maxItems":128,"items":{"$ref":"#/definitions/parameter"}}}}}}

package/build/dist/sender.d.ts

@@ -0,0 +1,141 @@
+import { type ActionRequest, type Confirm } from './confirm.js';
+import { type TraceCall } from './execution-trace.js';
+import { erc20Abi, type Address, type Hex } from 'viem';
+import type { SenderResult, TypedDataRequest, UnsignedTx } from '@oakagentkit/core/types';
+import { type WalletSigner } from './wallet.js';
+type Receipt = {
+    blockHash?: Hex;
+    transactionHash: Hex;
+    blockNumber: bigint;
+    status: 'success' | 'reverted';
+};
+type Call = {
+    account: Address;
+    to: Address;
+    data: Hex;
+    value: bigint;
+    gas?: bigint;
+    nonce?: number;
+};
+type SimulationCall = Call & ({
+    gasPrice?: bigint;
+    maxFeePerGas?: never;
+    maxPriorityFeePerGas?: never;
+} | {
+    gasPrice?: never;
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+});
+type SimulatedCall = {
+    data?: Hex;
+    returnData?: Hex;
+    logs?: unknown;
+    status: 'success' | 'failure';
+    gasUsed: bigint;
+    maxUsedGas?: bigint;
+};
+export interface ChainClient {
+    traceCall?(call: TraceCall): Promise<unknown>;
+    getChainId(): Promise<number>;
+    getBalance(args: {
+        address: Address;
+        blockTag: 'pending';
+    }): Promise<bigint>;
+    estimateMaxPriorityFeePerGas(): Promise<bigint>;
+    estimateGas(args: Call): Promise<bigint>;
+    simulateBlocks(args: {
+        blocks: [{
+            calls: SimulationCall[];
+        }];
+        validation: false;
+        traceTransfers: true;
+        blockNumber?: bigint;
+    }): Promise<readonly {
+        calls: readonly SimulatedCall[];
+    }[]>;
+    readContract(args: {
+        address: Address;
+        abi: typeof erc20Abi;
+        functionName: 'allowance';
+        args: readonly [Address, Address];
+        blockNumber?: bigint;
+    }): Promise<unknown>;
+    getTransactionCount(args: {
+        address: Address;
+    } & ({
+        blockTag: 'pending' | 'latest' | 'safe' | 'finalized';
+        blockNumber?: never;
+    } | {
+        blockNumber: bigint;
+        blockTag?: never;
+    })): Promise<number>;
+    getBlock(args: {
+        blockTag: 'latest' | 'safe' | 'finalized';
+        blockNumber?: never;
+    } | {
+        blockNumber: bigint;
+        blockTag?: never;
+    }): Promise<{
+        hash?: Hex | null;
+        number: bigint | null;
+        timestamp: bigint;
+        baseFeePerGas?: bigint | null;
+        gasLimit?: bigint;
+    }>;
+    getTransactionReceipt(args: {
+        hash: Hex;
+    }): Promise<Receipt>;
+    getTransaction(args: {
+        hash: Hex;
+    }): Promise<{
+        hash: Hex;
+    }>;
+    sendRawTransaction(args: {
+        serializedTransaction: Hex;
+    }): Promise<Hex>;
+    waitForTransactionReceipt(args: {
+        hash: Hex;
+        confirmations: number;
+        timeout: number;
+    }): Promise<Receipt>;
+}
+export type Finality = number | 'safe' | 'finalized';
+export declare const NOT_AFTER_SECONDS = 300;
+export type PreparedTx = UnsignedTx & {
+    notAfter?: number;
+};
+export type Reprepare = () => Promise<{
+    txs: PreparedTx[];
+    action?: ActionRequest;
+}>;
+export interface SenderOptions {
+    signer?: WalletSigner;
+    confirm?: Confirm;
+    clientFor?: (chainId: number) => ChainClient;
+    allowedChainIds?: readonly number[];
+    directory?: string;
+    finality?: Finality;
+    receiptTimeoutMs?: number;
+    now?: () => number;
+    notAfterSeconds?: number;
+    preview?: (text: string) => void | Promise<void>;
+}
+export interface LockedSender {
+    approvalStatus?(): Promise<string>;
+    send(txs: PreparedTx[], action?: ActionRequest, reprepare?: Reprepare): Promise<SenderResult>;
+    signTypedData(request: TypedDataRequest, action?: Pick<ActionRequest, 'name'>): Promise<Hex>;
+    assertCanPayGas(txs: PreparedTx[]): Promise<void>;
+}
+export declare class SenderError extends Error {
+}
+export declare function createSender(options?: SenderOptions): {
+    withAction: <T>(action: (locked: LockedSender) => Promise<T>) => Promise<T>;
+    send: (txs: PreparedTx[], action?: ActionRequest, reprepare?: Reprepare) => Promise<SenderResult>;
+    signTypedData: (request: TypedDataRequest, action?: Pick<ActionRequest, "name">) => Promise<`0x${string}`>;
+    assertCanPayGas: (txs: UnsignedTx[]) => Promise<void>;
+    blockNumber: (chainId?: number) => Promise<bigint>;
+};
+export declare const send: (txs: UnsignedTx[], options?: SenderOptions) => Promise<SenderResult>;
+export declare const signTypedData: (request: TypedDataRequest, options?: SenderOptions) => Promise<`0x${string}`>;
+export declare const assertCanPayGas: (txs: UnsignedTx[], options?: SenderOptions) => Promise<void>;
+export {};

package/build/dist/sender.js

@@ -0,0 +1 @@
+import{a,b,c,d,e,f}from"./chunks/U5VW3XSD.js";import"./chunks/YVAFJM4Y.js";import"./chunks/IVR4JOHU.js";import"./chunks/U3IXRJH7.js";import"./chunks/2NJCYRBM.js";import"./chunks/QIDB35RS.js";import"./chunks/67E2KBUQ.js";export{a as NOT_AFTER_SECONDS,b as SenderError,f as assertCanPayGas,c as createSender,d as send,e as signTypedData};