@invisi-labs/sdk 1.1.6 → 1.2.0

package/dist/provenance.d.ts

@@ -0,0 +1,34 @@
+import { PublicResult } from '@invisi-labs/protocol/provenance';
+export * from '@invisi-labs/protocol/provenance';
+import { ProvenanceClient } from '@invisi-labs/rpc/provenance';
+export * from '@invisi-labs/rpc/provenance';
+import { ProvenanceProvider } from '@invisi-labs/prover/provenance-witness';
+export * from '@invisi-labs/prover/provenance-witness';
+import { B as BroadcasterTransaction, P as ProvenanceProof } from './operation-bridge-CoECSxfi.js';
+export { a as PreparedProvenanceCapability } from './operation-bridge-CoECSxfi.js';
+import '@invisi-labs/primitives';
+import '@invisi-labs/prover';
+import '@invisi-labs/protocol';
+import '@invisi-labs/rpc/broadcaster';
+import '@invisi-labs/protocol/contracts';
+import 'ethers';
+import '@invisi-labs/rpc';
+
+interface ProvenanceOptions {
+    prover?: ProvenanceProvider;
+    client?: ProvenanceClient;
+    maxRootPages?: number;
+    maxLeaves?: number;
+}
+declare class Provenance {
+    #private;
+    private readonly options;
+    constructor(options?: ProvenanceOptions);
+    private client;
+    prove(ready: BroadcasterTransaction, options?: {
+        reprove?: boolean;
+    }): Promise<ProvenanceProof>;
+    submit(proof: ProvenanceProof): Promise<PublicResult>;
+}
+
+export { Provenance, type ProvenanceOptions, ProvenanceProof };

package/dist/provenance.js

@@ -0,0 +1,59 @@
+import {
+  validateProvenanceProof
+} from "./chunk-3D24ABYR.js";
+import {
+  operationProvenanceContext,
+  proveOperationProvenance,
+  readOperationProvenance
+} from "./chunk-R5YAOJKB.js";
+
+// src/provenance.ts
+export * from "@invisi-labs/protocol/provenance";
+export * from "@invisi-labs/rpc/provenance";
+export * from "@invisi-labs/prover/provenance-witness";
+
+// src/provenance/Provenance.ts
+import { OfficialProvenanceClients } from "@invisi-labs/rpc/provenance";
+var Provenance = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  #official = new OfficialProvenanceClients();
+  async client(scope) {
+    const client = this.options.client ?? await this.#official.get(scope);
+    if (BigInt(client.trust.chainId) !== BigInt(scope.chainId) || BigInt(client.trust.protocolAddress) !== BigInt(scope.protocolAddress))
+      throw Error("Provenance client deployment mismatch");
+    return client;
+  }
+  async prove(ready, options = {}) {
+    const cached = options.reprove ? void 0 : await readOperationProvenance(ready);
+    if (cached)
+      return validateProvenanceProof(cached, (await this.client(cached.context)).trust);
+    const prover = this.options.prover;
+    if (!prover) throw Error("NativeProver required to generate Provenance proof");
+    const scope = await operationProvenanceContext(ready);
+    const capability = await prover.getProvenanceCapability();
+    const client = await this.client(scope);
+    const proof = await proveOperationProvenance(
+      ready,
+      {
+        ...capability,
+        client,
+        ...this.options.maxRootPages === void 0 ? {} : { maxRootPages: this.options.maxRootPages },
+        ...this.options.maxLeaves === void 0 ? {} : { maxLeaves: this.options.maxLeaves }
+      },
+      options.reprove === true
+    );
+    return validateProvenanceProof(proof, client.trust);
+  }
+  async submit(proof) {
+    const copy = structuredClone(proof);
+    const client = await this.client(copy.context);
+    const packet = await validateProvenanceProof(copy, client.trust);
+    return client.submitSourceProof(packet.data, packet.sidecars);
+  }
+};
+export {
+  Provenance
+};
+//# sourceMappingURL=provenance.js.map

package/dist/provenance.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/provenance.ts","../src/provenance/Provenance.ts"],"sourcesContent":["export * from \"@invisi-labs/protocol/provenance\";\nexport * from \"@invisi-labs/rpc/provenance\";\nexport * from \"@invisi-labs/prover/provenance-witness\";\nexport { Provenance, type ProvenanceOptions } from \"./provenance/Provenance\";\nexport type { ProvenanceProof } from \"./provenance/proof-record\";\n\nexport type { PreparedProvenanceCapability } from \"./broadcaster/provenance-preparation\";\n","import { OfficialProvenanceClients, type ProvenanceClient } from \"@invisi-labs/rpc/provenance\";\nimport { type PublicResult, type Scope } from \"@invisi-labs/protocol/provenance\";\nimport { type ProvenanceProvider } from \"@invisi-labs/prover/provenance-witness\";\nimport {\n    proveOperationProvenance,\n    readOperationProvenance,\n    operationProvenanceContext,\n    type BroadcasterTransaction,\n} from \"../broadcaster/operation-bridge\";\nimport { validateProvenanceProof, type ProvenanceProof } from \"./proof-record\";\n\nexport interface ProvenanceOptions {\n    prover?: ProvenanceProvider;\n    client?: ProvenanceClient;\n    maxRootPages?: number;\n    maxLeaves?: number;\n}\n\nexport class Provenance {\n    readonly #official = new OfficialProvenanceClients();\n    constructor(private readonly options: ProvenanceOptions = {}) {}\n\n    private async client(scope: Scope): Promise<ProvenanceClient> {\n        const client = this.options.client ?? (await this.#official.get(scope));\n        if (\n            BigInt(client.trust.chainId) !== BigInt(scope.chainId) ||\n            BigInt(client.trust.protocolAddress) !== BigInt(scope.protocolAddress)\n        )\n            throw Error(\"Provenance client deployment mismatch\");\n        return client;\n    }\n\n    async prove(\n        ready: BroadcasterTransaction,\n        options: { reprove?: boolean } = {}\n    ): Promise<ProvenanceProof> {\n        const cached = options.reprove ? undefined : await readOperationProvenance(ready);\n        if (cached)\n            return validateProvenanceProof(cached, (await this.client(cached.context)).trust);\n        const prover = this.options.prover;\n        if (!prover) throw Error(\"NativeProver required to generate Provenance proof\");\n        const scope = await operationProvenanceContext(ready);\n        const capability = await prover.getProvenanceCapability();\n        const client = await this.client(scope);\n        const proof = await proveOperationProvenance(\n            ready,\n            {\n                ...capability,\n                client,\n                ...(this.options.maxRootPages === undefined\n                    ? {}\n                    : { maxRootPages: this.options.maxRootPages }),\n                ...(this.options.maxLeaves === undefined\n                    ? {}\n                    : { maxLeaves: this.options.maxLeaves }),\n            },\n            options.reprove === true\n        );\n        return validateProvenanceProof(proof, client.trust);\n    }\n\n    async submit(proof: ProvenanceProof): Promise<PublicResult> {\n        const copy = structuredClone(proof);\n        const client = await this.client(copy.context);\n        const packet = await validateProvenanceProof(copy, client.trust);\n        return client.submitSourceProof(packet.data, packet.sidecars);\n    }\n}\n"],"mappings":";;;;;;;;;;AAAA,cAAc;AACd,cAAc;AACd,cAAc;;;ACFd,SAAS,iCAAwD;AAkB1D,IAAM,aAAN,MAAiB;AAAA,EAEpB,YAA6B,UAA6B,CAAC,GAAG;AAAjC;AAAA,EAAkC;AAAA,EADtD,YAAY,IAAI,0BAA0B;AAAA,EAGnD,MAAc,OAAO,OAAyC;AAC1D,UAAM,SAAS,KAAK,QAAQ,UAAW,MAAM,KAAK,UAAU,IAAI,KAAK;AACrE,QACI,OAAO,OAAO,MAAM,OAAO,MAAM,OAAO,MAAM,OAAO,KACrD,OAAO,OAAO,MAAM,eAAe,MAAM,OAAO,MAAM,eAAe;AAErE,YAAM,MAAM,uCAAuC;AACvD,WAAO;AAAA,EACX;AAAA,EAEA,MAAM,MACF,OACA,UAAiC,CAAC,GACV;AACxB,UAAM,SAAS,QAAQ,UAAU,SAAY,MAAM,wBAAwB,KAAK;AAChF,QAAI;AACA,aAAO,wBAAwB,SAAS,MAAM,KAAK,OAAO,OAAO,OAAO,GAAG,KAAK;AACpF,UAAM,SAAS,KAAK,QAAQ;AAC5B,QAAI,CAAC,OAAQ,OAAM,MAAM,oDAAoD;AAC7E,UAAM,QAAQ,MAAM,2BAA2B,KAAK;AACpD,UAAM,aAAa,MAAM,OAAO,wBAAwB;AACxD,UAAM,SAAS,MAAM,KAAK,OAAO,KAAK;AACtC,UAAM,QAAQ,MAAM;AAAA,MAChB;AAAA,MACA;AAAA,QACI,GAAG;AAAA,QACH;AAAA,QACA,GAAI,KAAK,QAAQ,iBAAiB,SAC5B,CAAC,IACD,EAAE,cAAc,KAAK,QAAQ,aAAa;AAAA,QAChD,GAAI,KAAK,QAAQ,cAAc,SACzB,CAAC,IACD,EAAE,WAAW,KAAK,QAAQ,UAAU;AAAA,MAC9C;AAAA,MACA,QAAQ,YAAY;AAAA,IACxB;AACA,WAAO,wBAAwB,OAAO,OAAO,KAAK;AAAA,EACtD;AAAA,EAEA,MAAM,OAAO,OAA+C;AACxD,UAAM,OAAO,gBAAgB,KAAK;AAClC,UAAM,SAAS,MAAM,KAAK,OAAO,KAAK,OAAO;AAC7C,UAAM,SAAS,MAAM,wBAAwB,MAAM,OAAO,KAAK;AAC/D,WAAO,OAAO,kBAAkB,OAAO,MAAM,OAAO,QAAQ;AAAA,EAChE;AACJ;","names":[]}

package/dist/receipt-logs-8Msm_HZS.d.ts

@@ -0,0 +1,322 @@
+import { RegistrationPreparation, RegistrationOperation } from '@invisi-labs/rpc';
+import * as _invisi_labs_primitives from '@invisi-labs/primitives';
+import { WalletResponse, CreditDeliveryState, Note, authenticatedDecryptor } from '@invisi-labs/primitives';
+import * as _invisi_labs_protocol from '@invisi-labs/protocol';
+import { TransactionCall, CanonicalReceipt } from '@invisi-labs/protocol';
+import { O as OperationStatus, T as TransactionRuntime, d as PreparationIntent, e as OperationPlan, f as TransactionProveOptions, g as OperationAggregateMember, h as TransactionInfrastructure } from './operation-bridge-CoECSxfi.js';
+import { Hex, Address } from '@invisi-labs/protocol/contracts';
+import { TransactionOutput } from './note.js';
+import { Prover, ProofBundle } from '@invisi-labs/prover';
+import { T as TransactionIdentity, E as ExplicitTransferPreparation, a as ExplicitShieldPreparation, b as ExplicitCreateCreditPreparation, c as ExplicitDrawCreditPreparation, d as ExplicitUpdateCreditPreparation, e as ExplicitRevokeCreditPreparation } from './index-Crp-ZFiM.js';
+
+interface BroadcasterQuote {
+    token: string;
+    feeRecipient: string;
+    feeAmount: string;
+    deadline: string;
+    maxGas: string;
+    requestHash: string;
+}
+interface SignedBroadcasterQuote {
+    quote: BroadcasterQuote;
+    signature: string;
+    provenanceRequired?: boolean;
+    requestHashFormat?: string;
+    context?: {
+        chainId: bigint;
+        protocol: string;
+    };
+}
+
+type Runtime = TransactionRuntime & {
+    reprepare?: (intent: PreparationIntent) => Promise<OperationPlan>;
+};
+/** An immutable, local transaction handle. No wallet inventory, reservations or persistence. */
+declare class PreparedTransaction {
+    #private;
+    readonly status: OperationStatus;
+    private constructor();
+    static prepare(runtime: Runtime, plan: OperationPlan): PreparedTransaction;
+    broadcasterQuote(): SignedBroadcasterQuote | undefined;
+    get id(): string;
+    get kind(): "create-credit" | "update-credit" | "transfer" | "shield" | "draw-credit" | "revoke-credit";
+    estimateGas(options?: {
+        from?: `0x${string}`;
+    }): Promise<{
+        source: "rpc";
+        gasUnits: bigint;
+    }>;
+    getGasReference(): _invisi_labs_protocol.DocumentedGasReference;
+    /** Final Note outputs, including change; Credit outputs are not exported as IPN. */
+    getOutputs(): readonly TransactionOutput[];
+    preview(): {
+        id: string;
+        kind: "create-credit" | "update-credit" | "transfer" | "shield" | "draw-credit" | "revoke-credit";
+        status: OperationStatus;
+        context: {
+            tokenAddress: _invisi_labs_primitives.Address;
+            now?: bigint;
+            timestamp?: bigint;
+            chainId: bigint;
+            protocolAddress: _invisi_labs_primitives.Address;
+        };
+        inputs: number;
+        inputDetails: ({
+            kind: "notes";
+            commitment: `0x${string}`;
+            amount: bigint;
+            owner: `0x${string}`;
+            treeId: bigint;
+            leafIndex: number;
+        } | {
+            kind: "credits";
+            commitment: `0x${string}`;
+            revocationShard: bigint;
+            revocationSlot: bigint;
+            owner: `0x${string}`;
+            spender: `0x${string}`;
+            expiry: bigint;
+            availableCredit: bigint;
+            unlimited: boolean;
+            role: "owner" | "spender";
+            treeId: bigint;
+            leafIndex: number;
+        })[];
+        funding: {
+            payer: `0x${string}`;
+            amount: bigint;
+            authorization: "signature" | "none" | "caller";
+            sigNonce: bigint;
+            deadline: bigint;
+            permit: {
+                deadline: bigint;
+            };
+        };
+        creditOutputs: {
+            lastDay: bigint;
+            dailySpent: bigint;
+            lastMonth: bigint;
+            monthlySpent: bigint;
+            totalSpent: bigint;
+            availableCredit: bigint;
+            unlimited: boolean;
+            singleLimit: bigint;
+            dailyLimit: bigint;
+            monthlyLimit: bigint;
+            commitment: `0x${string}`;
+            revocationShard: bigint;
+            revocationSlot: bigint;
+            expiry: bigint;
+            owner: `0x${string}`;
+            spender: `0x${string}`;
+        }[] | undefined;
+        creditUpdate: _invisi_labs_primitives.CreditUpdateChanges | undefined;
+        creditDraw: {
+            grossAmount: bigint;
+            feeAmount: bigint;
+            netAmount: bigint;
+            payers: {
+                payer: _invisi_labs_primitives.Address;
+                amount: bigint;
+            }[];
+        } | undefined;
+        creditFeePayer: `0x${string}` | undefined;
+        outputs: {
+            commitment: `0x${string}`;
+            to: string;
+            amount: bigint;
+            change: boolean;
+        }[];
+        capacity: number | undefined;
+        deadline: bigint;
+        feeRecipient: `0x${string}` | undefined;
+        feeAmount: bigint;
+        fundingAmount: bigint;
+        fundingPayer: `0x${string}` | undefined;
+        withdrawalAmount: bigint;
+        withdrawalAddress: `0x${string}` | undefined;
+        permissions: {
+            walletAuthorization: boolean;
+            proof: boolean;
+            fundingAuthorization: boolean;
+        };
+    };
+    /** Obtain a firm quote before signing. This intent contains no private inputs or witness. */
+    exportBroadcasterIntent(): Promise<{
+        sendable: false;
+        data: Hex;
+    }>;
+    private current;
+    private stage;
+    exportRevocationAuthorization(): Promise<_invisi_labs_primitives.SigningRequest>;
+    withRevocationSignature(signature: Hex): Promise<PreparedTransaction>;
+    /** Export the same portable request used by managed native wallet transports. */
+    exportWalletRequest(id: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<_invisi_labs_primitives.WalletRequest<"wallet.authorize">>;
+    /** Independently validate host authorization against the retained request and frozen plan. */
+    withWalletResponse(response: WalletResponse, options?: {
+        signal?: AbortSignal;
+    }): Promise<PreparedTransaction>;
+    /** Public EIP-712 request; signing transport and key custody belong to the caller. */
+    exportWalletAuthorization(options?: {
+        signal?: AbortSignal;
+    }): Promise<_invisi_labs_primitives.SigningRequest>;
+    /** Attach an external EOA signature, retaining its witness only at the private proving boundary. */
+    withWalletSignature(signature: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<PreparedTransaction>;
+    /** Export only after proving when the funding authorization binds an actual proof hash. */
+    exportFundingAuthorization(options?: {
+        signal?: AbortSignal;
+    }): Promise<_invisi_labs_primitives.SigningRequest>;
+    /** Verify an external signature against this handle's own frozen operation. */
+    withFundingSignature(signature: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<PreparedTransaction>;
+    prove(options?: TransactionProveOptions): Promise<PreparedTransaction>;
+    prove(backend: Prover, options?: TransactionProveOptions): Promise<PreparedTransaction>;
+    private encode;
+    /** Shield caller funding needs no wallet signing or proof; this step only encodes its frozen request. */
+    ready(): Promise<PreparedTransaction>;
+    exportTransaction(): Promise<TransactionCall>;
+    exportProof(): ProofBundle;
+    exportAggregateMember(): OperationAggregateMember;
+    toJSON(): {
+        transaction: boolean;
+        id: string;
+        kind: "create-credit" | "update-credit" | "transfer" | "shield" | "draw-credit" | "revoke-credit";
+        status: OperationStatus;
+    };
+}
+
+/** Compose independent Chain RPC and indexed Protocol RPC with local wallet capabilities. */
+type InvisiOptions = Omit<TransactionInfrastructure, "wallet" | "protocol" | "coinSelector">;
+/** Public wallet and registry-specific inputs; signing remains external. */
+type RegistrationPreparationOptions = Pick<RegistrationPreparation, "update" | "deadline"> & Pick<TransactionIdentity, "wallet">;
+/** Stateless transaction preparation and independent infrastructure composition. */
+declare class Invisi {
+    #private;
+    constructor(options?: InvisiOptions);
+    /** A detached snapshot of shared infrastructure; wallet permissions and persistence stay external. */
+    getInfrastructure(): Readonly<InvisiOptions>;
+    private resolve;
+    /** Discover the selected chain's registry and prepare an independent signing request. */
+    prepareRegistration(options: RegistrationPreparationOptions): Promise<RegistrationOperation>;
+    private assertPublicIdentity;
+    private resolveExplicit;
+    prepareTransfer(options: ExplicitTransferPreparation): Promise<PreparedTransaction>;
+    prepareShield(options: ExplicitShieldPreparation): Promise<PreparedTransaction>;
+    prepareCreateCredit(options: ExplicitCreateCreditPreparation): Promise<PreparedTransaction>;
+    prepareDrawCredit(options: ExplicitDrawCreditPreparation): Promise<PreparedTransaction>;
+    prepareUpdateCredit(options: ExplicitUpdateCreditPreparation): Promise<PreparedTransaction>;
+    prepareRevokeCredit(options: ExplicitRevokeCreditPreparation): Promise<PreparedTransaction>;
+    toJSON(): {
+        invisi: boolean;
+    };
+}
+
+/** Stable codes returned by public SDK prepare* methods; inspect details instead of matching messages. */
+type InvisiErrorCode = 
+/**
+ * Other preparation failure, such as invalid amounts, expired deadlines,
+ * or conflicting registration state. Inspect message and cause.
+ */
+"PREPARATION_FAILED"
+/**
+ * Required infrastructure or permissions were not supplied.
+ * The capability field identifies what is missing.
+ */
+ | "MISSING_CAPABILITY"
+/**
+ * The recipient string is not a valid full 0i address or nonzero EVM owner address.
+ * No registration lookup is attempted for this invalid string.
+ */
+ | "INVALID_RECIPIENT"
+/**
+ * A successful lookup found no receiving keys for this short 0x owner
+ * at the queried state. Indexed data may lag behind the latest chain state.
+ * Full 0i addresses contain receiving keys and do not require registration.
+ */
+ | "EVM_ADDRESS_NOT_REGISTERED"
+/**
+ * Recipient lookup failed or returned invalid keys. Inspect cause.
+ * Registration status is unknown; this does not mean the owner is unregistered.
+ */
+ | "RECIPIENT_LOOKUP_FAILED";
+interface InvisiErrorDetails {
+    operation?: string;
+    address?: string;
+    /** Zero-based index into the caller's outputs array, excluding automatic change. */
+    outputIndex?: number;
+    field?: string;
+    capability?: string;
+    cause?: unknown;
+}
+/** Stable application-facing preparation failure with the original cause. */
+declare class InvisiError extends Error {
+    readonly code: InvisiErrorCode;
+    readonly operation: string | undefined;
+    readonly address: string | undefined;
+    readonly outputIndex: number | undefined;
+    readonly field: string | undefined;
+    readonly capability: string | undefined;
+    constructor(code: InvisiErrorCode, message: string, details?: InvisiErrorDetails);
+}
+/** Keep nested failures intact; do not infer business codes from English messages. */
+declare function prepareWithErrors<T>(operation: string, prepare: () => Promise<T>): Promise<T>;
+
+interface DiscoveryContext {
+    chainId: bigint;
+    protocolAddress: Address;
+}
+/** Decoded logs from complete canonical transaction receipts, including insertion logs. */
+interface DeliveryEventLog {
+    address: string;
+    eventName: string;
+    args?: Record<string, unknown>;
+    blockNumber?: bigint | null;
+    blockHash?: Hex | null;
+    transactionHash?: Hex | null;
+    logIndex?: number | null;
+    removed?: boolean;
+}
+interface DeliveryCandidate {
+    tokenAddress: Address;
+    treeId: bigint;
+    leafIndex: number;
+    commitment: Hex;
+    role: "funds" | "owner" | "spender";
+    delivery: {
+        ciphertext: Hex;
+        clue: Hex;
+    };
+    blockNumber: bigint;
+    blockHash: Hex;
+    transactionHash: Hex;
+}
+/** Correlate deliveries with canonical insertion events, never service-supplied balances or positions.
+ * The caller selects a confirmed chain/deployment and supplies complete decoded receipts.
+ */
+declare function extractDeliveryCandidates(logs: readonly DeliveryEventLog[], context: DiscoveryContext, confirmedThrough: bigint): DeliveryCandidate[];
+interface DiscoveredNote extends Omit<DeliveryCandidate, "delivery" | "role"> {
+    note: Note;
+}
+interface DiscoveredCredit extends Omit<DeliveryCandidate, "delivery"> {
+    role: "owner" | "spender";
+    state: CreditDeliveryState;
+}
+/** Authenticate private deliveries from a single batch of canonical receipts. */
+declare function decryptCandidates(logs: readonly DeliveryEventLog[], options: {
+    context: DiscoveryContext;
+    viewing: ReturnType<typeof authenticatedDecryptor>;
+    confirmedThrough: bigint;
+}): Promise<{
+    notes: DiscoveredNote[];
+    credits: DiscoveredCredit[];
+}>;
+
+/** Decode independently fetched canonical receipt bytes, never normalized service events. */
+declare function readProtocolLogs(receipt: CanonicalReceipt, protocolAddress: Address): DeliveryEventLog[];
+
+export { type DeliveryEventLog as D, Invisi as I, PreparedTransaction as P, type RegistrationPreparationOptions as R, type DiscoveredCredit as a, type DiscoveredNote as b, InvisiError as c, type InvisiErrorCode as d, type InvisiErrorDetails as e, type InvisiOptions as f, decryptCandidates as g, type DeliveryCandidate as h, type DiscoveryContext as i, extractDeliveryCandidates as j, prepareWithErrors as p, readProtocolLogs as r };