@oakagentkit/addon 0.0.0-stage → 0.1.0

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/U4YOG57X.js";import"./chunks/HGFLLHB6.js";import"./chunks/HLAZAI2Q.js";import"./chunks/QIDB35RS.js";import"./chunks/YVAFJM4Y.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,116 @@
+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;
+};
+type SimulatedCall = {
+    status: 'success' | 'failure';
+    gasUsed: bigint;
+    maxUsedGas?: bigint;
+};
+export interface ChainClient {
+    getChainId(): Promise<number>;
+    getBalance(args: {
+        address: Address;
+        blockTag: 'pending';
+    }): Promise<bigint>;
+    estimateMaxPriorityFeePerGas(): Promise<bigint>;
+    estimateGas(args: Call): Promise<bigint>;
+    simulateBlocks(args: {
+        blocks: [{
+            calls: Call[];
+        }];
+        validation: false;
+        traceTransfers: true;
+    }): Promise<readonly {
+        calls: readonly SimulatedCall[];
+    }[]>;
+    readContract(args: {
+        address: Address;
+        abi: typeof erc20Abi;
+        functionName: 'allowance';
+        args: readonly [Address, Address];
+    }): 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;
+    }>;
+    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 = 12;
+export type PreparedTx = UnsignedTx & {
+    notAfter?: number;
+};
+export interface SenderOptions {
+    signer?: WalletSigner;
+    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[]): Promise<SenderResult>;
+    signTypedData(request: TypedDataRequest): 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: UnsignedTx[]) => Promise<SenderResult>;
+    signTypedData: (request: TypedDataRequest) => 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/HLAZAI2Q.js";import"./chunks/QIDB35RS.js";import"./chunks/YVAFJM4Y.js";export{a as NOT_AFTER_SECONDS,b as SenderError,f as assertCanPayGas,c as createSender,d as send,e as signTypedData};

package/build/dist/session.d.ts

@@ -0,0 +1,45 @@
+import { type SessionIdentity } from '@oakagentkit/core/identity-link';
+import type { OakNetwork } from '@oakagentkit/core/addresses';
+import type { Hex, SessionPayload } from '@oakagentkit/core/types';
+import { type WalletSigner } from './wallet.js';
+export interface IdentitySession extends SessionPayload {
+    identity?: SessionIdentity;
+    nonce?: Hex;
+    sessionKey?: `0x${string}`;
+}
+export declare function createSession(options?: {
+    signer?: WalletSigner;
+    identity?: SessionIdentity;
+    sessionKey?: `0x${string}`;
+    network?: OakNetwork;
+    now?: () => number;
+    lifetime?: number;
+}): Promise<string>;
+export declare function verifySession(header: string, now?: number, network?: OakNetwork): Promise<IdentitySession>;
+export declare function createSessionManager(options: {
+    signer: WalletSigner;
+    network?: OakNetwork;
+    identity?: SessionIdentity;
+    now?: () => number;
+    refreshIdentity?: (identity: SessionIdentity) => Promise<SessionIdentity | undefined>;
+}): {
+    readonly identity: {
+        chainId: number;
+        registry: import("viem").Address;
+        agentId: import("@oakagentkit/core/types").DecimalString;
+        linkId?: Hex;
+    } | undefined;
+    setIdentity(value?: SessionIdentity): void;
+    clear: () => void;
+    get(): Promise<string>;
+    headers(method: string, path: string, body: string): Promise<Record<string, string>>;
+};
+export declare function signRequest(options: {
+    token: string;
+    signer: Pick<WalletSigner, 'signMessage'>;
+    method: string;
+    path: string;
+    body: string;
+    expires: number;
+    nonce?: Hex;
+}): Promise<string>;

package/build/dist/session.js

@@ -0,0 +1 @@
+import{a,b,c,d}from"./chunks/4B2GMIK7.js";export{a as createSession,c as createSessionManager,d as signRequest,b as verifySession};

package/build/dist/setup.d.ts

@@ -0,0 +1,24 @@
+import { type SessionIdentity } from '@oakagentkit/core/identity-link';
+import type { OakNetwork } from '@oakagentkit/core/addresses';
+import type { ToolArgs } from '@oakagentkit/core/types';
+import { type IdentityClient, type OwnerSign } from './identity.js';
+import type { WalletSigner } from './wallet.js';
+export type SetupRequest = {
+    mode: 'register';
+    profile?: ToolArgs;
+    tag?: boolean;
+} | {
+    mode: 'link';
+    agentId: string;
+};
+export declare function createSetup(options: {
+    network: OakNetwork;
+    signer: WalletSigner;
+    identity: IdentityClient;
+    callTool(name: string, args: ToolArgs): Promise<unknown>;
+    save(identity: SessionIdentity): Promise<void>;
+    signOwner?: OwnerSign;
+}): (request: SetupRequest) => Promise<{
+    identity: SessionIdentity;
+    summary: string;
+}>;

package/build/dist/setup.js

@@ -0,0 +1 @@
+import{a}from"./chunks/ILJVXWGD.js";import"./chunks/5HTX664S.js";import"./chunks/4B2GMIK7.js";import"./chunks/VZCMAMZL.js";import"./chunks/GONTF7K4.js";export{a as createSetup};

package/build/dist/subscribe.d.ts

@@ -0,0 +1,347 @@
+import { type Address, type PublicClient } from 'viem';
+import { type OakNetwork } from '@oakagentkit/core/addresses';
+import type { GrandfatherTree, GrandfatherProofResult } from '@oakagentkit/core/merkle';
+import type { ActionResult, NoteRefusal, NoteTarget, SignedPriceNote, ToolResponse, TypedDataRequest } from '@oakagentkit/core/types';
+import { type createSender, type LockedSender } from './sender.js';
+export declare const subscriptionAbi: readonly [{
+    readonly name: "subscribe";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "uint8";
+        readonly name: "plan";
+    }, {
+        readonly type: "uint256";
+        readonly name: "maxCount";
+    }, {
+        readonly type: "uint256";
+        readonly name: "maxPrice";
+    }, {
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "address";
+            readonly name: "wallet";
+        }, {
+            readonly type: "uint256";
+            readonly name: "oakPerEthE18";
+        }, {
+            readonly type: "uint64";
+            readonly name: "timestamp";
+        }, {
+            readonly type: "bytes32";
+            readonly name: "nonce";
+        }];
+        readonly name: "n";
+    }, {
+        readonly type: "bytes";
+        readonly name: "sig";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "subscribeWithAuthorization";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "maxCount";
+    }, {
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "address";
+            readonly name: "wallet";
+        }, {
+            readonly type: "uint256";
+            readonly name: "oakPerEthE18";
+        }, {
+            readonly type: "uint64";
+            readonly name: "timestamp";
+        }, {
+            readonly type: "bytes32";
+            readonly name: "nonce";
+        }];
+        readonly name: "n";
+    }, {
+        readonly type: "bytes";
+        readonly name: "sig";
+    }, {
+        readonly type: "bytes";
+        readonly name: "usdgAuth";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "subscribeGrandfatheredWithAuthorization";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "count";
+    }, {
+        readonly type: "bytes32[]";
+        readonly name: "proof";
+    }, {
+        readonly type: "bytes";
+        readonly name: "usdgAuth";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "renewWithAuthorization";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "bytes";
+        readonly name: "usdgAuth";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "renewNoHold";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "maxPrice";
+    }, {
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "address";
+            readonly name: "wallet";
+        }, {
+            readonly type: "uint256";
+            readonly name: "oakPerEthE18";
+        }, {
+            readonly type: "uint64";
+            readonly name: "timestamp";
+        }, {
+            readonly type: "bytes32";
+            readonly name: "nonce";
+        }];
+        readonly name: "n";
+    }, {
+        readonly type: "bytes";
+        readonly name: "sig";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "cancel";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "hasRecord";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly name: "previous";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly name: "retired";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly name: "plan";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint8";
+    }];
+}, {
+    readonly name: "paidUntil";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint64";
+    }];
+}, {
+    readonly name: "signupOakCount";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "grandfatherRoot";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "bytes32";
+    }];
+}, {
+    readonly name: "grandfatherDeadline";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint64";
+    }];
+}, {
+    readonly name: "quoteHolder";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "address";
+            readonly name: "wallet";
+        }, {
+            readonly type: "uint256";
+            readonly name: "oakPerEthE18";
+        }, {
+            readonly type: "uint64";
+            readonly name: "timestamp";
+        }, {
+            readonly type: "bytes32";
+            readonly name: "nonce";
+        }];
+        readonly name: "n";
+    }, {
+        readonly type: "bytes";
+        readonly name: "sig";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "count";
+    }, {
+        readonly type: "uint256";
+        readonly name: "burn";
+    }];
+}, {
+    readonly name: "quoteNoHold";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "address";
+            readonly name: "wallet";
+        }, {
+            readonly type: "uint256";
+            readonly name: "oakPerEthE18";
+        }, {
+            readonly type: "uint64";
+            readonly name: "timestamp";
+        }, {
+            readonly type: "bytes32";
+            readonly name: "nonce";
+        }];
+        readonly name: "n";
+    }, {
+        readonly type: "bytes";
+        readonly name: "sig";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "price";
+    }];
+}, {
+    readonly name: "NoteOutsideGuard";
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "spot";
+    }, {
+        readonly type: "uint256";
+        readonly name: "note";
+    }];
+}, {
+    readonly name: "OracleUnreadable";
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "source";
+    }];
+}, {
+    readonly name: "NoteExpired";
+    readonly type: "error";
+    readonly inputs: readonly [];
+}, {
+    readonly name: "NoteUsed";
+    readonly type: "error";
+    readonly inputs: readonly [];
+}, {
+    readonly name: "NoteBadSignature";
+    readonly type: "error";
+    readonly inputs: readonly [];
+}];
+export declare const HOLDER_PRICE = 9000000n;
+export declare const RENEW_WINDOW: bigint;
+export interface Deployment {
+    network: OakNetwork;
+    chainId: 4663 | 46630;
+    subscription: Address;
+    usdg: Address;
+    oak: Address;
+    oracle: Address;
+    ethUsdgPool: Address;
+}
+export interface LifecycleOptions {
+    wallet: Address;
+    deployment: Deployment;
+    client: PublicClient;
+    sender: Pick<ReturnType<typeof createSender>, 'withAction'>;
+    issueNote(target: NoteTarget): Promise<SignedPriceNote | NoteRefusal>;
+    grandfatherList?: () => Promise<GrandfatherTree | null>;
+    callTool?: (name: string, args: Record<string, unknown>) => Promise<ToolResponse<ActionResult>>;
+}
+export interface LifecycleResult {
+    ok: boolean;
+    access: boolean;
+    summary: string;
+    hashes: string[];
+}
+export interface SubscriptionRecord {
+    contract: Address;
+    plan: number;
+    paidUntil: bigint;
+    count: bigint;
+    retired: boolean;
+}
+export declare function usdgDomain(deployment: Pick<Deployment, 'network' | 'chainId' | 'usdg'>): TypedDataRequest['domain'];
+export declare function assertDeployment(deployment: Deployment): void;
+export declare class SubscriptionLifecycle {
+    readonly options: LifecycleOptions;
+    constructor(options: LifecycleOptions);
+    get deployment(): Deployment;
+    get wallet(): `0x${string}`;
+    now(): Promise<bigint>;
+    authoritative(): Promise<SubscriptionRecord | null>;
+    proof(record: SubscriptionRecord): Promise<GrandfatherProofResult | null>;
+    balance(token: Address): Promise<bigint>;
+    access(record: SubscriptionRecord | null): Promise<boolean>;
+    private plain;
+    action(action: (locked: LockedSender) => Promise<LifecycleResult>, retryNote?: boolean): Promise<LifecycleResult>;
+    private tx;
+    private funds;
+    private authorization;
+    private note;
+    private fresh;
+    pricedPayment(locked: LockedSender, contract: Address, plan: 'holder' | 'nohold', renewal?: boolean): Promise<LifecycleResult>;
+    holderPayment(locked: LockedSender, record: SubscriptionRecord, proof?: GrandfatherProofResult): Promise<LifecycleResult>;
+    subscribe(plan: 'holder' | 'nohold'): Promise<LifecycleResult>;
+    cancel(): Promise<LifecycleResult>;
+    register(noTag?: boolean): Promise<ToolResponse<ActionResult>>;
+}

package/build/dist/subscribe.js

@@ -0,0 +1 @@
+import{a,b,c,d,e,f}from"./chunks/HGFLLHB6.js";import"./chunks/HLAZAI2Q.js";import"./chunks/QIDB35RS.js";import"./chunks/YVAFJM4Y.js";export{b as HOLDER_PRICE,c as RENEW_WINDOW,f as SubscriptionLifecycle,e as assertDeployment,a as subscriptionAbi,d as usdgDomain};

package/build/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const version: string;

package/build/dist/version.js

@@ -0,0 +1 @@
+import{a}from"./chunks/4X7FLHGQ.js";export{a as version};

package/build/dist/wallet.d.ts

@@ -0,0 +1,11 @@
+import { type PrivateKeyAccount } from 'viem/accounts';
+import type { Address } from 'viem';
+export type WalletSigner = Readonly<Pick<PrivateKeyAccount, 'address' | 'signMessage' | 'signTransaction' | 'signTypedData'>>;
+export declare function createWallet(options?: {
+    recover?: boolean;
+    replace?: boolean;
+}): Promise<{
+    address: Address;
+}>;
+export declare function loadSigner(): Promise<WalletSigner>;
+export declare function exportKey(): Promise<void>;