@invisi-labs/protocol 1.1.5 → 1.1.7

package/dist/index.d.cts

@@ -1,69 +1,10 @@
+import { ProofTarget, CircuitName, ProofStatement, ProvingRequest } from '@invisi-labs/prover';
 import * as _invisi_labs_core from '@invisi-labs/core';
-import { Hex, Address, ReceivingKeyLookup, PublicWallet, CreditDeliveryState, AuthorizedStatement, Note } from '@invisi-labs/core';
-import { ContractRunner, Provider } from 'ethers';
+import { Address, Hex, CreditDeliveryState, AuthorizedStatement, Note, ReceivingKeyLookup, PublicWallet } from '@invisi-labs/core';
+import { F as FundingParams, D as Delivery, I as InputSource, C as CreateCreditParams, a as CancelCreditParams, b as CreditDrawParams, T as TopUpCreditParams, c as TransactRequest, d as CrossTreeTransactParams, S as ShieldParams, e as ShieldOutput } from './types-Bvakbfeb.cjs';
 import { DeploymentContext, CanonicalBlock, ProtocolDeployment, ProtocolRpcClient } from '@invisi-labs/rpc';
 export { CanonicalBlock, DeploymentContext, Membership, ProtocolDataProvider, ProtocolDataStatus, ProtocolUpdateRange, ProtocolUpdates } from '@invisi-labs/rpc';
-import { F as FundingParams, D as Delivery, I as InputSource, C as CreateCreditParams, a as CancelCreditParams, b as CreditDrawParams, T as TopUpCreditParams, c as TransactRequest, S as ShieldParams, d as ShieldOutput, e as CrossTreeTransactParams } from './types-BCTQjKzw.cjs';
-import { ProofTarget, CircuitName, ProofStatement, ProvingRequest } from '@invisi-labs/prover';
-
-interface RegistryContext {
-    chainId: bigint;
-    registryAddress: Address;
-    /** Optional explicit wall-clock value in seconds. Equality with deadline is valid. */
-    now?: bigint;
-}
-interface RegistryReceivingKeys {
-    viewingPublicKey: Hex;
-    clueKey: Hex;
-}
-interface AddressRegistration {
-    /** Nonzero EVM owner: 20 bytes or canonical zero-padded bytes32. */
-    walletIdentity: Hex;
-    keys: RegistryReceivingKeys;
-    /** The current registry nonce expected for this operation. */
-    nonce: bigint;
-    deadline: bigint;
-}
-interface RegistrationOptions {
-    update?: boolean;
-    /** Check a separately obtained current nonce before authorizing or encoding. */
-    expectedNonce?: bigint;
-}
-interface RegistrationCalldata {
-    to: Address;
-    callData: Hex;
-    value: 0n;
-}
-/** Standard registry EIP-712 data, independent of private WalletAuthorization. */
-declare function registrationTypedData(context: RegistryContext, registration: AddressRegistration, options?: RegistrationOptions): {
-    domain: {
-        name: string;
-        version: string;
-        chainId: bigint;
-        verifyingContract: `0x${string}`;
-    };
-    primaryType: string;
-    types: {
-        [x: string]: {
-            name: string;
-            type: string;
-        }[];
-    };
-    message: {
-        nonce: bigint;
-        deadline: bigint;
-        viewingPublicKey: Hex;
-        clueKey: Hex;
-        walletIdentity: string;
-    };
-};
-declare function registrationDigest(context: RegistryContext, registration: AddressRegistration, options?: RegistrationOptions): Hex;
-/** Encode an owner call (empty signature) or an EIP-712 / ERC-1271 authorized relay. */
-declare function buildRegistrationCalldata(context: RegistryContext, registration: AddressRegistration, signature: Hex, options?: RegistrationOptions): RegistrationCalldata;
-/** Ethers runner used for registry contract reads. */
-type RegistryReadClient = ContractRunner;
-/** One receivingKeysOf query per short address; RPC failures propagate unchanged. */
-declare function createRegistryReceivingKeyLookup(client: RegistryReadClient, registryAddress: Address): ReceivingKeyLookup;
+import { Provider, ContractRunner } from 'ethers';
 
 interface TransactionContext extends DeploymentContext {
     tokenAddress: Address;
@@ -108,6 +49,7 @@ declare const pad: (v: readonly bigint[], n: number) => bigint[];
 /** Receipt/transport validation must not reject unrelated future wallet codecs. */
 declare function normalizeOpaqueDelivery(value: Delivery, options?: {
     empty?: boolean;
+    allowEmpty?: boolean;
 }): Delivery;
 declare const deliveriesHash: (v: readonly Delivery[]) => Hex;
 declare function normalizeFunding(input?: FundingInput): FundingParams;
@@ -135,165 +77,7 @@ declare const fundingFields: readonly [{
     readonly type: "uint256";
 }];
 
-interface ProtocolLog {
-    address: Address;
-    data: Hex;
-    topics: readonly Hex[];
-    transactionHash: Hex;
-    logIndex: number;
-}
-interface CanonicalReceipt {
-    block: CanonicalBlock;
-    transactionHash: Hex;
-    logs: readonly ProtocolLog[];
-    status?: "success" | "reverted";
-}
-interface ChainReader {
-    getChainId(): Promise<bigint>;
-    /** Required when a selected deployment includes a receiving-key registry. */
-    getProtocolAddressRegistry?(address: Address): Promise<Address>;
-    getCode(address: Address): Promise<Hex>;
-    getBlock(number: bigint): Promise<CanonicalBlock>;
-    getLatestBlockNumber(): Promise<bigint>;
-    getFundingNonce(context: DeploymentContext, payer: Address, block: CanonicalBlock): Promise<bigint>;
-    isKnownRoot(context: DeploymentContext, treeId: bigint, root: Hex, block: CanonicalBlock): Promise<boolean>;
-    getTransaction(hash: Hex): Promise<(TransactionCall & {
-        transactionHash: Hex;
-        from: Address;
-        nonce: bigint;
-    }) | null>;
-    getReceipt(hash: Hex): Promise<CanonicalReceipt | null>;
-    isSpent(context: DeploymentContext, nullifiers: readonly Hex[], block: CanonicalBlock): Promise<readonly boolean[]>;
-}
-interface TransactionCall {
-    to: Address;
-    data: Hex;
-    value: bigint;
-}
-/** Optional deployment provenance queries, independent of token policy. */
-interface FactoryReader {
-    getFactoryInstanceAddress(factory: Address, salt: Hex): Promise<Address>;
-    isFactoryInstance(factory: Address, instance: Address): Promise<boolean>;
-    getInstanceFactory(instance: Address): Promise<Address>;
-}
-
-interface RegistryReader extends Pick<ChainReader, "getChainId" | "getCode" | "getBlock" | "getLatestBlockNumber" | "getTransaction" | "getReceipt"> {
-    /** Validate arbitrary ERC-1271 bytes for a contract owner; transport errors propagate. */
-    isValidRegistrationSignature?(owner: Address, digest: Hex, signature: Hex): Promise<boolean>;
-    getRegistryNonce(context: RegistryContext, walletIdentity: Hex, block: CanonicalBlock): Promise<bigint>;
-}
-interface RegistrationPreparation {
-    wallet: PublicWallet;
-    reader: RegistryReader;
-    deadline?: bigint;
-    update?: boolean;
-}
-type RegistrationStatus = "prepared" | "ready" | "submitted" | "confirmed" | "uncertain" | "failed" | "expired" | "reorged";
-declare class RegistrationOperation {
-    #private;
-    readonly status: RegistrationStatus;
-    private constructor();
-    static prepare(registry: AddressRegistry, options: RegistrationPreparation): Promise<RegistrationOperation>;
-    get id(): string;
-    preview(): {
-        update: boolean;
-        walletIdentity: Hex;
-        keys: RegistryReceivingKeys;
-        nonce: bigint;
-        deadline: bigint;
-        id: string;
-        status: RegistrationStatus;
-        chainId: bigint;
-        registryAddress: `0x${string}`;
-    };
-    /** Export portable EIP-712 data for external signing. */
-    exportRegistrationAuthorization(options?: {
-        signal?: AbortSignal;
-    }): Promise<_invisi_labs_core.SigningRequest>;
-    /** Validate and attach an independently obtained EOA or ERC-1271 signature. */
-    withSignature(signature: string, options?: {
-        signal?: AbortSignal;
-    }): Promise<RegistrationOperation>;
-    /** Empty signatures require the transaction sender to be the wallet owner. */
-    authorizeDirect(): Promise<RegistrationOperation>;
-    typedData(): {
-        domain: {
-            name: string;
-            version: string;
-            chainId: bigint;
-            verifyingContract: `0x${string}`;
-        };
-        primaryType: string;
-        types: {
-            [x: string]: {
-                name: string;
-                type: string;
-            }[];
-        };
-        message: {
-            nonce: bigint;
-            deadline: bigint;
-            viewingPublicKey: Hex;
-            clueKey: Hex;
-            walletIdentity: string;
-        };
-    };
-    private call;
-    exportTransaction(): Promise<TransactionCall>;
-    private validateFreshness;
-    /** Associate a signed/broadcast transaction; ethers owns sending and receipt waiting. */
-    trackTransaction(transactionHash: string): RegistrationOperation;
-    reconcile(options?: {
-        transactionHash?: Hex;
-        signal?: AbortSignal;
-    }): Promise<RegistrationOperation>;
-    toJSON(): {
-        id: string;
-        kind: string;
-        status: RegistrationStatus;
-    };
-}
-
-interface AddressRegistryOptions {
-    lookup?: ReceivingKeyLookup;
-    expectedRuntimeCodeHash?: Hex;
-}
-/** Independent registry deployment and nonce domain, selected by the application. */
-declare class AddressRegistry {
-    #private;
-    readonly context: Readonly<RegistryContext>;
-    readonly expectedRuntimeCodeHash: Hex | undefined;
-    constructor(context: RegistryContext, options?: AddressRegistryOptions);
-    validateDeployment(reader: Pick<RegistryReader, "getChainId" | "getCode">): Promise<void>;
-    prepareRegistration(options: RegistrationPreparation): Promise<RegistrationOperation>;
-    resolve(address: string): Promise<string>;
-    typedData(registration: AddressRegistration, options?: RegistrationOptions): {
-        domain: {
-            name: string;
-            version: string;
-            chainId: bigint;
-            verifyingContract: `0x${string}`;
-        };
-        primaryType: string;
-        types: {
-            [x: string]: {
-                name: string;
-                type: string;
-            }[];
-        };
-        message: {
-            nonce: bigint;
-            deadline: bigint;
-            viewingPublicKey: Hex;
-            clueKey: Hex;
-            walletIdentity: string;
-        };
-    };
-    digest(registration: AddressRegistration, options?: RegistrationOptions): `0x${string}`;
-    buildCall(registration: AddressRegistration, signature: `0x${string}`, options?: RegistrationOptions): RegistrationCalldata;
-}
-
-declare const CREATE_CREDIT_FIELDS: readonly ["token", "sources", "nullifiers", "creditCommitment", "changeCommitment", "owner", "expiry", "deadline"];
+declare const CREATE_CREDIT_FIELDS: readonly ["token", "sources", "nullifiers", "creditCommitment", "changeCommitment", "owner", "expiry", "deadline", "feeRecipient", "feeAmount"];
 /** Public checks cannot establish ownership or conservation: those are enforced by the proof. */
 declare function validateCreateCreditRequest(c: TransactionContext, p: CreateCreditParams, cs: readonly Delivery[], funding?: FundingInput): {
     sources: {
@@ -310,6 +94,8 @@ declare function validateCreateCreditRequest(c: TransactionContext, p: CreateCre
     deadline: bigint;
     deliveries: Delivery[];
     funding: FundingParams;
+    feeRecipient: `0x${string}`;
+    feeAmount: bigint;
     chainId: bigint;
     protocolAddress: Hex;
     tokenAddress: Hex;
@@ -436,6 +222,8 @@ declare function validateCancelCreditRequest(c: TransactionContext, p: CancelCre
     owner: `0x${string}`;
     amount: bigint;
     deadline: bigint;
+    feeRecipient: `0x${string}`;
+    feeAmount: bigint;
     chainId: bigint;
     protocolAddress: Hex;
     tokenAddress: Hex;
@@ -459,6 +247,8 @@ declare function validateTopUpCreditRequest(c: TransactionContext, p: TopUpCredi
         deadline: bigint;
         deliveries: Delivery[];
         funding: FundingParams;
+        feeRecipient: `0x${string}`;
+        feeAmount: bigint;
         chainId: bigint;
         protocolAddress: Hex;
         tokenAddress: Hex;
@@ -610,63 +400,26 @@ declare function buildTopUpCreditCalldata(p: BuildTopUpCreditCalldataParams): {
     approveAmount: bigint;
 };
 
-declare const TRANSACT_CAPACITIES: readonly [14, 56, 112, 168];
-type TransactCapacity = (typeof TRANSACT_CAPACITIES)[number];
-declare function selectTransactCapacity(inputs: number, outputs: number): TransactCapacity;
-type TransactRequestParams = CrossTreeTransactParams;
-declare function normalizeTransactRequest(c: TransactionContext, p: TransactRequestParams, cs: readonly Delivery[], funding?: FundingInput): {
-    capacity: 112 | 14 | 56 | 168;
-    sources: {
-        treeId: bigint;
-        merkleRoot: `0x${string}`;
-    }[];
-    nullifiers: `0x${string}`[];
-    outputCommitments: `0x${string}`[];
-    inputCount: number;
-    outputCount: number;
-    sourceCount: number;
-    inputTreeIds: bigint[];
-    merkleRoots: bigint[];
-    slotValues: bigint[];
-    deliveries: Delivery[];
-    deliveriesHash: `0x${string}`;
-    withdrawalAddress: `0x${string}`;
-    withdrawalAmount: bigint;
-    deadline: bigint;
-    depositAmount: bigint;
-    depositPayer: `0x${string}`;
-    funding: FundingParams;
-    chainId: bigint;
-    protocolAddress: Hex;
-    tokenAddress: Hex;
-    now?: bigint;
-    timestamp?: bigint;
-};
-declare function transactPublicInputs(c: TransactionContext, p: TransactRequestParams, cs: readonly Delivery[], f?: FundingInput): `0x${string}`[];
-declare function encodeTransactTypedData(c: TransactionContext, p: TransactRequestParams, deliveries: readonly Delivery[], f?: FundingInput): {
-    domain: {
-        name: string;
-        version: string;
-        chainId: bigint;
-        verifyingContract: `0x${string}`;
-    };
-    types: {
-        readonly WalletAuthorization: readonly [{
-            readonly name: "operation";
-            readonly type: "bytes32";
-        }, {
-            readonly name: "statementHash";
-            readonly type: "bytes32";
-        }];
-    };
-    primaryType: "WalletAuthorization";
-    message: {
-        operation: `0x${string}`;
-        statementHash: `0x${string}`;
+interface BuildTransactAggregateCalldataParams {
+    context: DeploymentContext & {
+        now?: bigint;
     };
+    proof: Hex;
+    requests: readonly TransactRequest[];
+    caller?: Address;
+}
+declare function buildTransactAggregateCalldata(p: BuildTransactAggregateCalldataParams): {
+    data: Hex;
+    capacity: 14;
 };
-declare function transactFundingRequestHash(proof: Hex, p: TransactRequestParams, cs: readonly Delivery[]): `0x${string}`;
-declare function encodeTransactFundingTypedData(c: TransactionContext, proof: Hex, p: TransactRequestParams, cs: readonly Delivery[], funding: FundingInput): {
+type AggregateMemberInput = Pick<TransactRequest, "params" | "deliveries"> & {
+    funding?: FundingInput;
+};
+/** Atomic aggregate funding binds the member statement rather than the aggregate proof bytes. */
+declare function aggregateMemberRequestHash(c: TransactionContext, r: AggregateMemberInput): Hex;
+/** Router adapter business words (58 per member), not the aggregate circuit statement. */
+declare function aggregatePublicInputs(c: TransactionContext, requests: readonly AggregateMemberInput[]): `0x${string}`[];
+declare function encodeAggregateFundingTypedData(c: TransactionContext, r: AggregateMemberInput): {
     domain: {
         name: string;
         version: string;
@@ -700,6 +453,43 @@ declare function encodeTransactFundingTypedData(c: TransactionContext, proof: He
         deadline: bigint;
     };
 };
+
+declare const TRANSACT_CAPACITIES: readonly [14, 56, 112, 168];
+type TransactCapacity = (typeof TRANSACT_CAPACITIES)[number];
+declare function selectTransactCapacity(inputs: number, outputs: number): TransactCapacity;
+type TransactRequestParams = CrossTreeTransactParams;
+declare function normalizeTransactRequest(c: TransactionContext, p: TransactRequestParams, cs: readonly Delivery[], funding?: FundingInput): {
+    capacity: 14 | 56 | 112 | 168;
+    sources: {
+        treeId: bigint;
+        merkleRoot: `0x${string}`;
+    }[];
+    nullifiers: `0x${string}`[];
+    outputCommitments: `0x${string}`[];
+    inputCount: number;
+    outputCount: number;
+    sourceCount: number;
+    inputTreeIds: bigint[];
+    merkleRoots: bigint[];
+    slotValues: bigint[];
+    deliveries: Delivery[];
+    deliveriesHash: `0x${string}`;
+    withdrawalAddress: `0x${string}`;
+    withdrawalAmount: bigint;
+    feeRecipient: `0x${string}`;
+    feeAmount: bigint;
+    deadline: bigint;
+    depositAmount: bigint;
+    depositPayer: `0x${string}`;
+    funding: FundingParams;
+    chainId: bigint;
+    protocolAddress: Hex;
+    tokenAddress: Hex;
+    now?: bigint;
+    timestamp?: bigint;
+};
+declare function transactPublicInputs(c: TransactionContext, p: TransactRequestParams, cs: readonly Delivery[], f?: FundingInput): `0x${string}`[];
+
 interface BuildTransactCalldataParams {
     context: TransactionContext;
     proof: Hex;
@@ -710,21 +500,10 @@ interface BuildTransactCalldataParams {
 }
 declare function buildTransactCalldata(p: BuildTransactCalldataParams): {
     data: `0x${string}`;
-    capacity: 112 | 14 | 56 | 168;
+    capacity: 14 | 56 | 112 | 168;
     approveAmount: bigint;
 };
-interface BuildTransactAggregateCalldataParams {
-    context: DeploymentContext & {
-        now?: bigint;
-    };
-    proof: Hex;
-    requests: readonly TransactRequest[];
-    caller?: Address;
-}
-declare function buildTransactAggregateCalldata(p: BuildTransactAggregateCalldataParams): {
-    data: Hex;
-    capacity: 14;
-};
+
 interface BuildShieldCalldataParams {
     context: TransactionContext;
     params: ShieldParams;
@@ -734,7 +513,6 @@ interface BuildShieldCalldataParams {
     caller?: Address;
 }
 declare function validateShieldRequest(p: BuildShieldCalldataParams): Promise<FundingParams>;
-declare function shieldFundingRequestHash(params: ShieldParams, outputs: readonly ShieldOutput[], cs: readonly Delivery[]): Hex;
 declare function encodeShieldFundingTypedData(p: BuildShieldCalldataParams): Promise<{
     domain: {
         name: string;
@@ -773,49 +551,49 @@ declare function buildShieldCalldata(p: BuildShieldCalldataParams): Promise<{
     data: Hex;
     approveAmount: bigint;
 }>;
-/** Full active user-circuit public inputs: business statement followed by EIP-712 digest limbs. */
-declare function transactUserPublicInputs(c: TransactionContext, p: TransactRequestParams, cs: readonly Delivery[], f?: FundingInput): `0x${string}`[];
-type AggregateMemberInput = Pick<TransactRequest, "params" | "deliveries"> & {
-    funding?: FundingInput;
-};
-/** Atomic aggregate funding binds the member statement rather than the aggregate proof bytes. */
-declare function aggregateMemberRequestHash(c: TransactionContext, r: AggregateMemberInput): Hex;
-/** Router adapter business words (56 per member), not the aggregate circuit statement. */
-declare function aggregatePublicInputs(c: TransactionContext, requests: readonly AggregateMemberInput[]): `0x${string}`[];
-declare function encodeAggregateFundingTypedData(c: TransactionContext, r: AggregateMemberInput): {
-    domain: {
-        name: string;
-        version: string;
-        chainId: bigint;
-        verifyingContract: Hex;
-    };
-    primaryType: "FundTransact";
-    types: {
-        FundTransact: readonly [{
-            readonly name: "requestHash";
-            readonly type: "bytes32";
-        }, {
-            readonly name: "payer";
-            readonly type: "address";
-        }, {
-            readonly name: "amount";
-            readonly type: "uint256";
-        }, {
-            readonly name: "sigNonce";
-            readonly type: "uint256";
-        }, {
-            readonly name: "deadline";
-            readonly type: "uint256";
-        }];
-    };
-    message: {
-        requestHash: `0x${string}`;
-        payer: `0x${string}`;
-        amount: bigint;
-        sigNonce: bigint;
-        deadline: bigint;
-    };
-};
+declare function shieldFundingRequestHash(params: ShieldParams, outputs: readonly ShieldOutput[], cs: readonly Delivery[]): Hex;
+
+interface ProtocolLog {
+    address: Address;
+    data: Hex;
+    topics: readonly Hex[];
+    transactionHash: Hex;
+    logIndex: number;
+}
+interface CanonicalReceipt {
+    block: CanonicalBlock;
+    transactionHash: Hex;
+    logs: readonly ProtocolLog[];
+    status?: "success" | "reverted";
+}
+interface ChainReader {
+    getChainId(): Promise<bigint>;
+    /** Required when a selected deployment includes a receiving-key registry. */
+    getProtocolAddressRegistry?(address: Address): Promise<Address>;
+    getCode(address: Address): Promise<Hex>;
+    getBlock(number: bigint): Promise<CanonicalBlock>;
+    getLatestBlockNumber(): Promise<bigint>;
+    getFundingNonce(context: DeploymentContext, payer: Address, block: CanonicalBlock): Promise<bigint>;
+    isKnownRoot(context: DeploymentContext, treeId: bigint, root: Hex, block: CanonicalBlock): Promise<boolean>;
+    getTransaction(hash: Hex): Promise<(TransactionCall & {
+        transactionHash: Hex;
+        from: Address;
+        nonce: bigint;
+    }) | null>;
+    getReceipt(hash: Hex): Promise<CanonicalReceipt | null>;
+    isSpent(context: DeploymentContext, nullifiers: readonly Hex[], block: CanonicalBlock): Promise<readonly boolean[]>;
+}
+interface TransactionCall {
+    to: Address;
+    data: Hex;
+    value: bigint;
+}
+/** Optional deployment provenance queries, independent of token policy. */
+interface FactoryReader {
+    getFactoryInstanceAddress(factory: Address, salt: Hex): Promise<Address>;
+    isFactoryInstance(factory: Address, instance: Address): Promise<boolean>;
+    getInstanceFactory(instance: Address): Promise<Address>;
+}
 
 interface TokenProtocolOptions {
     expectedRuntimeCodeHash?: Hex;
@@ -830,7 +608,7 @@ declare class TokenProtocol {
     }): Promise<void>;
     transact(request: Omit<BuildTransactCalldataParams, "context">): {
         data: `0x${string}`;
-        capacity: 112 | 14 | 56 | 168;
+        capacity: 14 | 56 | 112 | 168;
         approveAmount: bigint;
         to: `0x${string}`;
         value: bigint;
@@ -873,62 +651,6 @@ declare class TokenProtocol {
     };
 }
 
-interface ProtocolOptions {
-    deployment: ProtocolDeployment;
-}
-/** A multi-token deployment. Asset support is always read from the chain. */
-declare class Protocol {
-    readonly deployment: Readonly<ProtocolDeployment>;
-    readonly context: Readonly<DeploymentContext>;
-    constructor(options: ProtocolOptions);
-    /** Load the selected deployment and verify its contract against Chain RPC before returning. */
-    static fromRpc(rpc: Pick<ProtocolRpcClient, "getDeployment">, provider: Provider, options?: {
-        signal?: AbortSignal;
-    }): Promise<Protocol>;
-    validateDeployment(connection: Provider | (Pick<ChainReader, "getChainId" | "getCode"> & {
-        getProtocolVersion?(address: Address): Promise<bigint>;
-        getProtocolAddressRegistry?(address: Address): Promise<Address>;
-    })): Promise<void>;
-    aggregate(request: Omit<BuildTransactAggregateCalldataParams, "context">): {
-        data: Hex;
-        capacity: 14;
-        to: `0x${string}`;
-        value: bigint;
-    };
-    /** Build an operation context for one asset within this same deployment. */
-    forToken(tokenAddress: Address): TokenProtocol;
-}
-
-interface VerifyNoteCommitmentParams {
-    walletIdentity: `0x${string}`;
-    tokenAddress: `0x${string}`;
-    amount: bigint;
-    nonce: `0x${string}`;
-    noteCommitment: `0x${string}`;
-    chainId: bigint;
-}
-declare function verifyNoteCommitment(params: VerifyNoteCommitmentParams): Promise<boolean>;
-interface VerifyCreditCommitmentParams extends Partial<_invisi_labs_core.CreditPolicy> {
-    chainId: bigint;
-    spenderWalletIdentity: `0x${string}`;
-    ownerWalletIdentity: `0x${string}`;
-    spenderPayout: `0x${string}`;
-    ownerPayout: `0x${string}`;
-    tokenAddress: `0x${string}`;
-    amount: bigint;
-    nonce: bigint;
-    expiry: bigint;
-    creditSharedKey: bigint;
-    /** Server-returned value to verify against the locally recomputed commitment. */
-    creditCommitment: `0x${string}`;
-}
-/**
- * Hashes the received shared key locally, recomputes the Credit leaf and compares it to the
- * server-returned value. A mismatch means the server folded a wrong nonce
- * (or other parameter) — the caller MUST abort and not create a Credit.
- */
-declare function verifyCreditCommitment(params: VerifyCreditCommitmentParams): Promise<boolean>;
-
 interface NoteMembership {
     note: Note;
     treeId: bigint;
@@ -943,7 +665,11 @@ interface CreditMembership {
 }
 interface TransactWitnessParams extends Omit<BuildTransactCalldataParams, "proof" | "context"> {
     inputs: readonly NoteMembership[];
-    outputs: readonly Note[];
+    outputs: readonly (Note | {
+        identity: Hex;
+        amount: bigint;
+        note?: Note;
+    })[];
     authorization?: AuthorizedStatement;
     target?: ProofTarget;
 }
@@ -974,25 +700,311 @@ interface TopUpCreditWitnessParams extends Omit<CreateCreditWitnessParams, "para
     params: TopUpCreditParams;
     previous: CreditMembership;
 }
-/** Local typed assembly for authenticated circuit releases; no network or backend selection. */
+
+/** Assemble witnesses through operation-specific builders with shared validation. */
 declare class WitnessBuilder {
     #private;
     constructor(protocol: TokenProtocol);
     static statement(circuitName: CircuitName, expectedPublicInputs: readonly Hex[], target?: ProofTarget): ProofStatement;
-    private context;
-    private authority;
-    private membership;
-    private noteLeaf;
-    private creditLeaf;
-    private noteInputs;
     transact(p: TransactWitnessParams): Promise<ProvingRequest>;
-    private creation;
     createCredit(p: CreateCreditWitnessParams): Promise<ProvingRequest>;
     cancelCredit(p: CancelCreditWitnessParams): Promise<ProvingRequest>;
     drawCredit(p: DrawCreditWitnessParams): Promise<ProvingRequest>;
     topUpCredit(p: TopUpCreditWitnessParams): Promise<ProvingRequest>;
 }
 
+interface ProtocolOptions {
+    deployment: ProtocolDeployment;
+}
+/** A multi-token deployment. Asset support is always read from the chain. */
+declare class Protocol {
+    readonly deployment: Readonly<ProtocolDeployment>;
+    readonly context: Readonly<DeploymentContext>;
+    constructor(options: ProtocolOptions);
+    /** Load the selected deployment and verify its contract against Chain RPC before returning. */
+    static fromRpc(rpc: Pick<ProtocolRpcClient, "getDeployment">, provider: Provider, options?: {
+        signal?: AbortSignal;
+    }): Promise<Protocol>;
+    validateDeployment(connection: Provider | (Pick<ChainReader, "getChainId" | "getCode"> & {
+        getProtocolVersion?(address: Address): Promise<bigint>;
+        getProtocolAddressRegistry?(address: Address): Promise<Address>;
+    })): Promise<void>;
+    aggregate(request: Omit<BuildTransactAggregateCalldataParams, "context">): {
+        data: Hex;
+        capacity: 14;
+        to: `0x${string}`;
+        value: bigint;
+    };
+    /** Build an operation context for one asset within this same deployment. */
+    forToken(tokenAddress: Address): TokenProtocol;
+}
+
+declare function encodeTransactTypedData(c: TransactionContext, p: TransactRequestParams, deliveries: readonly Delivery[], f?: FundingInput): {
+    domain: {
+        name: string;
+        version: string;
+        chainId: bigint;
+        verifyingContract: `0x${string}`;
+    };
+    types: {
+        readonly WalletAuthorization: readonly [{
+            readonly name: "operation";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "statementHash";
+            readonly type: "bytes32";
+        }];
+    };
+    primaryType: "WalletAuthorization";
+    message: {
+        operation: `0x${string}`;
+        statementHash: `0x${string}`;
+    };
+};
+declare function transactFundingRequestHash(proof: Hex, p: TransactRequestParams, cs: readonly Delivery[]): `0x${string}`;
+declare function encodeTransactFundingTypedData(c: TransactionContext, proof: Hex, p: TransactRequestParams, cs: readonly Delivery[], funding: FundingInput): {
+    domain: {
+        name: string;
+        version: string;
+        chainId: bigint;
+        verifyingContract: Hex;
+    };
+    primaryType: "FundTransact";
+    types: {
+        FundTransact: readonly [{
+            readonly name: "requestHash";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "payer";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+        }, {
+            readonly name: "sigNonce";
+            readonly type: "uint256";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }];
+    };
+    message: {
+        requestHash: `0x${string}`;
+        payer: `0x${string}`;
+        amount: bigint;
+        sigNonce: bigint;
+        deadline: bigint;
+    };
+};
+
+/** Full active user-circuit public inputs: business statement followed by EIP-712 digest limbs. */
+declare function transactUserPublicInputs(c: TransactionContext, p: TransactRequestParams, cs: readonly Delivery[], f?: FundingInput): `0x${string}`[];
+
+interface RegistryContext {
+    chainId: bigint;
+    registryAddress: Address;
+    /** Optional explicit wall-clock value in seconds. Equality with deadline is valid. */
+    now?: bigint;
+}
+interface RegistryReceivingKeys {
+    viewingPublicKey: Hex;
+    clueKey: Hex;
+}
+interface AddressRegistration {
+    /** Nonzero EVM owner: 20 bytes or canonical zero-padded bytes32. */
+    ownerAddress: Hex;
+    keys: RegistryReceivingKeys;
+    /** The current registry nonce expected for this operation. */
+    nonce: bigint;
+    deadline: bigint;
+}
+interface RegistrationOptions {
+    update?: boolean;
+    /** Check a separately obtained current nonce before authorizing or encoding. */
+    expectedNonce?: bigint;
+}
+interface RegistrationCalldata {
+    to: Address;
+    callData: Hex;
+    value: 0n;
+}
+/** Standard registry EIP-712 data, independent of private WalletAuthorization. */
+declare function registrationTypedData(context: RegistryContext, registration: AddressRegistration, options?: RegistrationOptions): {
+    domain: {
+        name: string;
+        version: string;
+        chainId: bigint;
+        verifyingContract: `0x${string}`;
+    };
+    primaryType: string;
+    types: {
+        [x: string]: {
+            name: string;
+            type: string;
+        }[];
+    };
+    message: {
+        nonce: bigint;
+        deadline: bigint;
+        viewingPublicKey: Hex;
+        clueKey: Hex;
+        walletIdentity: string;
+    };
+};
+declare function registrationDigest(context: RegistryContext, registration: AddressRegistration, options?: RegistrationOptions): Hex;
+/** Encode an owner call (empty signature) or an EIP-712 / ERC-1271 authorized relay. */
+declare function buildRegistrationCalldata(context: RegistryContext, registration: AddressRegistration, signature: Hex, options?: RegistrationOptions): RegistrationCalldata;
+/** Ethers runner used for registry contract reads. */
+type RegistryReadClient = ContractRunner;
+/** One receivingKeysOf query per short address; RPC failures propagate unchanged. */
+declare function createRegistryReceivingKeyLookup(client: RegistryReadClient, registryAddress: Address): ReceivingKeyLookup;
+
+interface RegistryReader extends Pick<ChainReader, "getChainId" | "getCode" | "getBlock" | "getLatestBlockNumber" | "getTransaction" | "getReceipt"> {
+    /** Validate arbitrary ERC-1271 bytes for a contract owner; transport errors propagate. */
+    isValidRegistrationSignature?(owner: Address, digest: Hex, signature: Hex): Promise<boolean>;
+    getRegistryNonce(context: RegistryContext, ownerAddress: Hex, block: CanonicalBlock): Promise<bigint>;
+}
+interface RegistrationPreparation {
+    wallet: PublicWallet;
+    reader: RegistryReader;
+    deadline?: bigint;
+    update?: boolean;
+}
+type RegistrationStatus = "prepared" | "ready" | "submitted" | "confirmed" | "uncertain" | "failed" | "expired" | "reorged";
+declare class RegistrationOperation {
+    #private;
+    readonly status: RegistrationStatus;
+    private constructor();
+    static prepare(registry: AddressRegistry, options: RegistrationPreparation): Promise<RegistrationOperation>;
+    get id(): string;
+    preview(): {
+        update: boolean;
+        ownerAddress: Hex;
+        keys: RegistryReceivingKeys;
+        nonce: bigint;
+        deadline: bigint;
+        id: string;
+        status: RegistrationStatus;
+        chainId: bigint;
+        registryAddress: `0x${string}`;
+    };
+    /** Export portable EIP-712 data for external signing. */
+    exportRegistrationAuthorization(options?: {
+        signal?: AbortSignal;
+    }): Promise<_invisi_labs_core.SigningRequest>;
+    /** Validate and attach an independently obtained EOA or ERC-1271 signature. */
+    withSignature(signature: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<RegistrationOperation>;
+    /** Empty signatures require the transaction sender to be the wallet owner. */
+    authorizeDirect(): Promise<RegistrationOperation>;
+    typedData(): {
+        domain: {
+            name: string;
+            version: string;
+            chainId: bigint;
+            verifyingContract: `0x${string}`;
+        };
+        primaryType: string;
+        types: {
+            [x: string]: {
+                name: string;
+                type: string;
+            }[];
+        };
+        message: {
+            nonce: bigint;
+            deadline: bigint;
+            viewingPublicKey: Hex;
+            clueKey: Hex;
+            walletIdentity: string;
+        };
+    };
+    private call;
+    exportTransaction(): Promise<TransactionCall>;
+    private validateFreshness;
+    /** Associate a signed/broadcast transaction; ethers owns sending and receipt waiting. */
+    trackTransaction(transactionHash: string): RegistrationOperation;
+    reconcile(options?: {
+        transactionHash?: Hex;
+        signal?: AbortSignal;
+    }): Promise<RegistrationOperation>;
+    toJSON(): {
+        id: string;
+        kind: string;
+        status: RegistrationStatus;
+    };
+}
+
+interface AddressRegistryOptions {
+    lookup?: ReceivingKeyLookup;
+    expectedRuntimeCodeHash?: Hex;
+}
+/** Independent registry deployment and nonce domain, selected by the application. */
+declare class AddressRegistry {
+    #private;
+    readonly context: Readonly<RegistryContext>;
+    readonly expectedRuntimeCodeHash: Hex | undefined;
+    constructor(context: RegistryContext, options?: AddressRegistryOptions);
+    validateDeployment(reader: Pick<RegistryReader, "getChainId" | "getCode">): Promise<void>;
+    prepareRegistration(options: RegistrationPreparation): Promise<RegistrationOperation>;
+    resolve(address: string): Promise<string>;
+    typedData(registration: AddressRegistration, options?: RegistrationOptions): {
+        domain: {
+            name: string;
+            version: string;
+            chainId: bigint;
+            verifyingContract: `0x${string}`;
+        };
+        primaryType: string;
+        types: {
+            [x: string]: {
+                name: string;
+                type: string;
+            }[];
+        };
+        message: {
+            nonce: bigint;
+            deadline: bigint;
+            viewingPublicKey: Hex;
+            clueKey: Hex;
+            walletIdentity: string;
+        };
+    };
+    digest(registration: AddressRegistration, options?: RegistrationOptions): `0x${string}`;
+    buildCall(registration: AddressRegistration, signature: `0x${string}`, options?: RegistrationOptions): RegistrationCalldata;
+}
+
+interface VerifyNoteCommitmentParams {
+    ownerAddress: `0x${string}`;
+    tokenAddress: `0x${string}`;
+    amount: bigint;
+    nonce: `0x${string}`;
+    noteCommitment: `0x${string}`;
+    chainId: bigint;
+}
+declare function verifyNoteCommitment(params: VerifyNoteCommitmentParams): Promise<boolean>;
+interface VerifyCreditCommitmentParams extends Partial<_invisi_labs_core.CreditPolicy> {
+    chainId: bigint;
+    spenderWalletIdentity: `0x${string}`;
+    ownerWalletIdentity: `0x${string}`;
+    spenderPayout: `0x${string}`;
+    ownerPayout: `0x${string}`;
+    tokenAddress: `0x${string}`;
+    amount: bigint;
+    nonce: bigint;
+    expiry: bigint;
+    creditSharedKey: bigint;
+    /** Server-returned value to verify against the locally recomputed commitment. */
+    creditCommitment: `0x${string}`;
+}
+/**
+ * Hashes the received shared key locally, recomputes the Credit leaf and compares it to the
+ * server-returned value. A mismatch means the server folded a wrong nonce
+ * (or other parameter) — the caller MUST abort and not create a Credit.
+ */
+declare function verifyCreditCommitment(params: VerifyCreditCommitmentParams): Promise<boolean>;
+
 /**
  * Query the selected factory. The caller still verifies the returned deployment profile.
  * Calls `factory.getInstanceAddress(salt)` on-chain.