@invisi-labs/sdk 1.1.5 → 1.1.7

package/dist/broadcaster-preparation-DMxxZ_1Q.d.ts

@@ -0,0 +1,587 @@
+import { Note, CreditDeliveryState, ReceivingKeyLookup, Hex as Hex$2, Wallet, PublicWallet, AuthorizedStatement } from '@invisi-labs/core';
+import * as _invisi_labs_prover from '@invisi-labs/prover';
+import { Hex, Prover, ProverOptions, AggregateMember, ProofBundle } from '@invisi-labs/prover';
+import * as _invisi_labs_protocol from '@invisi-labs/protocol';
+import { FundingInput, TransactionContext, CanonicalBlock, NoteMembership, TransactRequestParams, CreditMembership, Protocol, ChainReader, ProtocolDataProvider, TokenProtocol } from '@invisi-labs/protocol';
+import * as ethers from 'ethers';
+import { Interface, Provider } from 'ethers';
+import { Hex as Hex$1, Delivery, Address, ShieldParams, ShieldOutput, CreateCreditParams, CreditDrawParams, CancelCreditParams, TopUpCreditParams, TransactRequest } from '@invisi-labs/protocol/contracts';
+
+declare const broadcasterQuoteTypes: {
+    Quote: {
+        name: string;
+        type: string;
+    }[];
+};
+interface BroadcasterQuote {
+    token: string;
+    feeRecipient: string;
+    feeAmount: string;
+    deadline: string;
+    maxGas: string;
+    requestHash: string;
+}
+interface SignedBroadcasterQuote {
+    quote: BroadcasterQuote;
+    signature: string;
+    context?: {
+        chainId: bigint;
+        protocol: string;
+    };
+}
+interface BroadcasterTrust {
+    chainId: bigint;
+    protocol: string;
+    signer: string;
+}
+declare function broadcasterQuoteDomain(trust: BroadcasterTrust): {
+    name: string;
+    version: string;
+    chainId: bigint;
+    verifyingContract: string;
+};
+declare const broadcasterTransactInterface: Interface;
+/** Decode a canonical supported direct public intent. Draw, registry and aggregates are excluded. */
+declare function decodeBroadcasterIntent(data: string): {
+    fragment: ethers.FunctionFragment;
+    method: string;
+    args: ethers.Result;
+    proof: string;
+    request: {
+        params: any;
+        funding: any;
+        deliveries: any;
+    };
+};
+/** Domain-separated final public intent: omit only proof bytes and funding.signature. */
+declare function broadcasterRequestHash(data: string): string;
+declare function verifyBroadcasterQuote(signed: SignedBroadcasterQuote, trust: BroadcasterTrust, data: string, now?: bigint): BroadcasterQuote;
+interface BroadcasterStatus {
+    id: string;
+    state: "pending" | "submitted" | "confirmed" | "reverted" | "uncertain";
+    transactionHash?: string;
+}
+type BroadcasterTransport = (request: {
+    jsonrpc: "2.0";
+    id: number;
+    method: string;
+    params: unknown;
+}) => Promise<unknown>;
+interface BroadcasterConfiguration {
+    endpoint: string;
+    quoteSigner: string;
+    feeRecipient: string;
+}
+declare class BroadcasterClient {
+    readonly configuration: Readonly<BroadcasterConfiguration>;
+    readonly url: string;
+    readonly transport: BroadcasterTransport;
+    private requestId;
+    constructor(configuration: BroadcasterConfiguration, transport?: BroadcasterTransport);
+    private call;
+    fee(token: string, data?: string): Promise<{
+        feeRecipient: string;
+        feeAmount: string;
+        maxGas: string;
+    }>;
+    quote(data: string, context: {
+        chainId: bigint;
+        protocol: string;
+    }): Promise<SignedBroadcasterQuote>;
+    submit(data: string, signed: SignedBroadcasterQuote, idempotencyKey: string): Promise<BroadcasterStatus>;
+    status(id: string): Promise<BroadcasterStatus>;
+}
+declare class BroadcasterRpcError extends Error {
+    readonly code: number;
+    constructor(code: number, message: string);
+}
+
+interface WalletScope {
+    namespace: string;
+    chainId: bigint;
+    protocolAddress: Hex;
+    ownerAddress: Hex;
+}
+declare function creditReservationKey(commitment: string): string;
+interface Checkpoint {
+    number: bigint;
+    hash: Hex;
+}
+type SpentState = "unknown" | "unspent" | "spent";
+interface ReceiptPosition {
+    commitment: Hex;
+    treeId: bigint;
+    leafIndex: number;
+    blockNumber: bigint;
+    blockHash: Hex;
+    transactionHash?: Hex;
+}
+interface NoteRecord extends ReceiptPosition {
+    note: Note;
+    spent: SpentState;
+    checkedThrough?: Checkpoint;
+}
+interface CreditRecord extends ReceiptPosition {
+    receivingKeySource?: {
+        kind: "draw" | "top-up";
+        commitment: Hex;
+    };
+    state: CreditDeliveryState;
+    role: "owner" | "spender";
+    spent: SpentState;
+    checkedThrough?: Checkpoint;
+}
+type OperationStatus = "prepared" | "authorized" | "proved" | "ready" | "submitted" | "confirmed" | "failed" | "expired" | "uncertain" | "reorged";
+
+/** Minimal input count by descending amount, with deterministic tree/position/commitment ties. */
+type SelectableNote = Pick<NoteRecord, "note" | "commitment" | "treeId" | "leafIndex" | "spent">;
+
+type AddressLookup = "chain" | "protocol-rpc";
+/** Capture deployment pins before a Protocol is bound to an operation's token. */
+declare function configureRecipientInfrastructure<T extends TransactionInfrastructure>(options: T): T;
+/** Internal lookup plumbing; public APIs never accept resolver functions. */
+declare function recipientLookup(options: object, source?: AddressLookup): ReceivingKeyLookup;
+
+interface NoteOutputContext {
+    chainId: bigint;
+    protocolAddress: Hex$1;
+    tokenAddress: Hex$1;
+}
+type NoteOutputRecipient = {
+    type: "evm";
+    address: string;
+    envelope?: boolean;
+    addressLookup?: AddressLookup;
+    nonce?: bigint | undefined;
+} | {
+    type: "invisi";
+    address: string;
+    nonce?: bigint | undefined;
+} | {
+    type: "identity";
+    identity: Hex$1;
+};
+type EncryptedRecipient = {
+    type: "evm";
+    address: string;
+    envelope?: true;
+    addressLookup?: AddressLookup;
+    nonce?: bigint | undefined;
+} | {
+    type: "invisi";
+    address: string;
+    nonce?: bigint | undefined;
+};
+type PaymentRequest = NoteOutputContext & {
+    amount: bigint;
+} & ({
+    recipient: EncryptedRecipient;
+    payload?: Uint8Array;
+} | {
+    recipient: {
+        type: "evm";
+        address: string;
+        envelope: false;
+        addressLookup?: AddressLookup;
+        nonce?: bigint | undefined;
+    } | {
+        type: "identity";
+        identity: Hex$1;
+    };
+    payload?: never;
+});
+/** Local payment choices; these never rewrite the encoded request. */
+interface NoteOutputExecutionOptions {
+    nonce?: bigint;
+    addressLookup?: AddressLookup;
+}
+
+/** Immutable output statement and optional recoverable opening. */
+declare class NoteOutput {
+    readonly to: string;
+    readonly ipp: string;
+    readonly amount: bigint;
+    readonly identity: Hex$1;
+    readonly commitment: Hex$1;
+    readonly deliveryFingerprint: Hex$1;
+    /** Encrypted EVM delivery is resolved by preparation; the original offline intent stays pending. */
+    readonly deliveryPending: boolean;
+    readonly context: NoteOutputContext;
+    readonly recipient: NoteOutputRecipient;
+    readonly nonce: bigint | undefined;
+    readonly payload: Uint8Array;
+    readonly preparedOutput: PreparedOutput;
+    private constructor();
+    /** Private offline delivery data; does not assert that the output has been mined. */
+    exportPaymentNote(): string;
+    static create(input: PaymentRequest | string, execution?: NoteOutputExecutionOptions): Promise<NoteOutput>;
+    assertCommitment(expectedHex: Hex$1): void;
+    get note(): Note | undefined;
+    get delivery(): Delivery;
+}
+
+interface GasBenchmarkShape {
+    kind: OperationPlan["kind"];
+    target: string;
+    capacity: number;
+    noteInputs: number;
+    noteOutputs: number;
+    sourceTrees: number;
+    creditInputs: number;
+    creditOutputs: number;
+    creditRemainders: number;
+    funding: "none" | "caller" | "signature";
+    permit: boolean;
+    deliveryBytes: number;
+}
+interface GasBenchmarkDeployment {
+    chainId: string;
+    protocolAddress: Hex$2;
+    runtimeCodeHash: Hex$2 | null;
+    tokenAddress: Hex$2;
+}
+interface GasBenchmarkCircuit {
+    circuitName: string;
+    target: string;
+    artifactSha256: string;
+    vkSha256: string;
+}
+interface GasBenchmarkSample {
+    gasUsed: string;
+    transactionHash: Hex$2;
+    blockNumber: string;
+    blockHash: Hex$2;
+    calldataBytes: number;
+}
+interface GasBenchmarkProfile {
+    formatVersion: 1;
+    id: string;
+    deployment: GasBenchmarkDeployment;
+    source: {
+        protocolCommit: string;
+        fingerprints?: {
+            protocolSourceSha256: string;
+            dirtyDiffSha256: string;
+            compiledArtifactsSha256: string;
+            creditManifestSha256: string;
+            userManifestSha256: string;
+            sdkSourceSha256: string;
+        };
+        toolchain?: {
+            solidity: string;
+            barretenberg: string;
+            noir: string;
+            evmVersion: string;
+            optimizerRuns: number;
+            anvil: string;
+        };
+        blockGasLimit?: string;
+        runtimeContracts?: Record<string, {
+            address: Hex$2;
+            runtimeCodeHash: Hex$2;
+        }>;
+        measuredAt: string;
+        chain: string;
+        hardfork: string;
+        token: string;
+        verifier: "real";
+        assumptions: string[];
+    };
+    measurements: Array<{
+        id: string;
+        shape: GasBenchmarkShape;
+        circuit: GasBenchmarkCircuit | null;
+        samples: GasBenchmarkSample[];
+    }>;
+}
+interface GasEstimateRequest {
+    deployment: GasBenchmarkDeployment;
+    shape: GasBenchmarkShape;
+    circuit: GasBenchmarkCircuit | null;
+}
+type BenchmarkGasEstimate = {
+    source: "benchmark";
+    request: GasEstimateRequest;
+} & ({
+    available: false;
+    reason: "deployment-not-covered" | "shape-not-covered" | "recursive-member-only";
+} | {
+    available: true;
+    gasUnits: bigint;
+    range: {
+        min: bigint;
+        max: bigint;
+        kind: "observed";
+    };
+    samples: number;
+    profileId: string;
+    measurementId: string;
+    evidence: GasBenchmarkProfile["source"];
+});
+/** Pre-proof reference only; ethers must estimate the final transaction independently. */
+interface GasReference {
+    gasUnits: bigint;
+}
+
+interface CoinSelector {
+    select(candidates: readonly NoteRecord[], requiredAmount: bigint): readonly Hex$1[] | Promise<readonly Hex$1[]>;
+}
+interface FundingTypedData {
+    domain: Record<string, unknown>;
+    primaryType: string;
+    types: Record<string, readonly {
+        name: string;
+        type: string;
+    }[]>;
+    message: Record<string, unknown>;
+}
+interface FundingSigner {
+    readonly address: Address;
+    signTypedData(data: FundingTypedData): Promise<Hex$1>;
+}
+interface FundingAuthorizationVerifier {
+    verifyTypedData(data: FundingTypedData & {
+        address: Address;
+        signature: Hex$1;
+    }): Promise<boolean>;
+}
+interface FundingSource {
+    payer: Address;
+    amount: bigint;
+    authorization?: "signature" | "caller";
+    sigNonce?: bigint;
+    deadline?: bigint;
+    permit?: NonNullable<FundingInput["permit"]>;
+}
+/** Public submission mode; backend proof targets are selected internally. */
+type TransactionExecution = "single" | "aggregate";
+interface TransactionProveOptions extends ProverOptions {
+    /** Defaults to single. Aggregate produces a member for a separate aggregate submission. */
+    execution?: TransactionExecution;
+}
+interface TransferPreparation {
+    tokenAddress: Address;
+    /** Explicit subset for managed inventory; detached calls already supply inputs. */
+    commitments?: readonly Hex$1[];
+    /** Public ERC20 payout. Empty private outputs are allowed when a payout is present. */
+    withdrawal?: {
+        to: Address;
+        amount: bigint;
+    };
+    /** Immediate public fee paid from this operation's token. */
+    fee?: {
+        recipient: Address;
+        amount: bigint;
+    };
+    outputs: readonly NoteOutput[];
+    funding?: FundingSource;
+    deadline?: bigint;
+}
+interface ShieldPreparation {
+    fee?: {
+        recipient: Address;
+        amount: bigint;
+    };
+    tokenAddress: Address;
+    outputs: readonly NoteOutput[];
+    funding: FundingSource;
+    deadline?: bigint;
+}
+interface PreparedOutput {
+    context: NoteOutputContext;
+    recipient: NoteOutputRecipient;
+    amount: bigint;
+    note?: Note;
+    commitment: Hex$1;
+    identity: Hex$1;
+    delivery: Delivery;
+    /** Only offline encrypted EVM outputs may await registry-key resolution. */
+    deliveryPending?: true;
+    address: string;
+    change: boolean;
+}
+interface CreateCreditPreparation {
+    fee?: {
+        recipient: Address;
+        amount: bigint;
+    };
+    /** Version-specific application data. Omission uses built-in v1 with no data. */
+    payload?: Uint8Array;
+    singleLimit?: bigint;
+    dailyLimit?: bigint;
+    monthlyLimit?: bigint;
+    tokenAddress: Address;
+    spender: string;
+    amount: bigint;
+    expiry: bigint;
+    funding?: FundingSource;
+    deadline?: bigint;
+}
+interface DrawCreditPreparation {
+    tokenAddress: Address;
+    credits: readonly {
+        credit: Hex$1;
+        amount: bigint;
+        payload?: Uint8Array;
+    }[];
+    deadline?: bigint;
+}
+interface TopUpCreditPreparation {
+    fee?: {
+        recipient: Address;
+        amount: bigint;
+    };
+    /** Version-specific application data. Omission uses built-in v1 with no data. */
+    payload?: Uint8Array;
+    /** Omission inherits the previous limit; zero disables it without clearing usage. */
+    singleLimit?: bigint;
+    dailyLimit?: bigint;
+    monthlyLimit?: bigint;
+    tokenAddress: Address;
+    credit: Hex$1;
+    additionalAmount: bigint;
+    expiry?: bigint;
+    funding?: FundingSource;
+    deadline?: bigint;
+}
+interface CancelCreditPreparation {
+    fee?: {
+        recipient: Address;
+        amount: bigint;
+    };
+    tokenAddress: Address;
+    credit: Hex$1;
+    deadline?: bigint;
+}
+interface PreparedCreditOutput {
+    state: CreditDeliveryState;
+    commitment: Hex$1;
+    deliveries: [Delivery, Delivery];
+}
+interface PreparedCreditInput extends CreditMembership {
+    commitment: Hex$1;
+    role: "owner" | "spender";
+}
+interface CreditPlan {
+    inputs: PreparedCreditInput[];
+    outputs: PreparedCreditOutput[];
+    deliveries: Delivery[];
+    creation?: CreateCreditParams;
+    draw?: CreditDrawParams;
+    cancel?: CancelCreditParams;
+    topUp?: TopUpCreditParams;
+    amounts?: bigint[];
+}
+interface OperationPlan {
+    intent?: PreparationIntent;
+    version: 1;
+    id: string;
+    kind: "transfer" | "shield" | "create-credit" | "draw-credit" | "top-up-credit" | "cancel-credit";
+    context: TransactionContext;
+    scope: WalletScope;
+    preparedAt: CanonicalBlock;
+    deadline: bigint;
+    outputs: PreparedOutput[];
+    inputs: Array<NoteMembership & {
+        commitment: Hex$1;
+    }>;
+    funding: FundingInput;
+    fundingMode: "none" | "signature" | "caller";
+    params?: TransactRequestParams;
+    shieldParams?: ShieldParams;
+    shieldOutputs?: ShieldOutput[];
+    capacity?: number;
+    credit?: CreditPlan;
+    statement?: _invisi_labs_prover.ProofStatement;
+}
+interface SavedOperation {
+    plan: OperationPlan;
+    broadcasterQuote?: SignedBroadcasterQuote;
+    proof?: ProofBundle;
+    call?: _invisi_labs_protocol.TransactionCall;
+    externalized?: boolean;
+    generation: number;
+    claim?: {
+        stage: string;
+        token: string;
+    };
+}
+interface TransactionInfrastructure {
+    gasBenchmarks?: readonly GasBenchmarkProfile[];
+    wallet: Wallet | PublicWallet;
+    protocol: Protocol;
+    chainReader?: ChainReader;
+    protocolRpc?: ProtocolDataProvider;
+    prover?: Prover;
+    fundingVerifier?: FundingAuthorizationVerifier;
+    /** Optional ethers provider used by per-output direct-chain receiving-key lookup. */
+    provider?: Provider;
+    coinSelector?: CoinSelector;
+    transactionTTL?: bigint;
+}
+interface TransactionRuntime {
+    options: Omit<TransactionInfrastructure, "protocol"> & {
+        protocol: TokenProtocol;
+    };
+    scope: WalletScope;
+    reader: ChainReader;
+}
+interface LocalOperationSecrets {
+    authorization?: AuthorizedStatement;
+}
+interface OperationAggregateMember extends AggregateMember {
+    context: TransactionContext;
+    request: TransactRequest;
+}
+/** Data required while preparing an operation; it does not own persistence or reservations. */
+interface PreparationRuntime<Result> extends TransactionRuntime {
+    readInventory(): Promise<PreparationInventory>;
+    complete(plan: OperationPlan): Promise<Result>;
+    explicitInputs?: boolean;
+    inputSelection?: readonly Hex$1[];
+    changeAddress?: string;
+}
+interface PreparationInventory {
+    reservations: Record<string, string>;
+    invalidated?: string;
+    observedThrough?: Checkpoint;
+    notes: Record<string, SelectableNote>;
+    credits: Record<string, Pick<CreditRecord, "state" | "commitment" | "treeId" | "leafIndex" | "role" | "spent">>;
+}
+
+type PreparationIntent = {
+    kind: "transfer";
+    options: TransferPreparation;
+} | {
+    kind: "shield";
+    options: ShieldPreparation;
+} | {
+    kind: "create-credit";
+    options: CreateCreditPreparation;
+} | {
+    kind: "top-up-credit";
+    options: TopUpCreditPreparation;
+} | {
+    kind: "cancel-credit";
+    options: CancelCreditPreparation;
+};
+type BroadcasterFeeSource = "public-funding" | "private-inputs" | "payout";
+interface WithBroadcasterOptions {
+    maxFeeAmount: bigint;
+    feeSource?: BroadcasterFeeSource;
+    maxAttempts?: number;
+    /** Optional app-owned permit signing, requested once for the final gross funding amount. */
+    fundingPermit?: (request: {
+        payer: `0x${string}`;
+        amount: bigint;
+        tokenAddress: `0x${string}`;
+        protocolAddress: `0x${string}`;
+    }) => Promise<NonNullable<TransferPreparation["funding"]>["permit"]>;
+}
+declare function prepareIntent(runtime: PreparationRuntime<OperationPlan>, intent: PreparationIntent): Promise<OperationPlan>;
+declare function prepareBroadcasterPlan(plan: OperationPlan, reprepare: (intent: PreparationIntent) => Promise<OperationPlan>, client: BroadcasterClient, options: WithBroadcasterOptions): Promise<{
+    plan: OperationPlan;
+    quote: SignedBroadcasterQuote;
+}>;
+
+export { type LocalOperationSecrets as $, broadcasterTransactInterface as A, BroadcasterClient as B, type CancelCreditPreparation as C, type DrawCreditPreparation as D, decodeBroadcasterIntent as E, type FundingAuthorizationVerifier as F, type GasBenchmarkCircuit as G, verifyBroadcasterQuote as H, type GasEstimateRequest as I, type OperationPlan as J, type BenchmarkGasEstimate as K, type SavedOperation as L, type TransactionRuntime as M, NoteOutput as N, type OperationAggregateMember as O, type PaymentRequest as P, type OperationStatus as Q, type PreparationRuntime as R, type ShieldPreparation as S, type TopUpCreditPreparation as T, type TransactionInfrastructure as U, type AddressLookup as V, type WithBroadcasterOptions as W, type Checkpoint as X, type CoinSelector as Y, type CreditPlan as Z, type CreditRecord as _, type BroadcasterConfiguration as a, type NoteRecord as a0, type PreparationIntent as a1, type PreparationInventory as a2, type PreparedCreditInput as a3, type PreparedCreditOutput as a4, type PreparedOutput as a5, type ReceiptPosition as a6, type SpentState as a7, type WalletScope as a8, configureRecipientInfrastructure as a9, creditReservationKey as aa, prepareBroadcasterPlan as ab, prepareIntent as ac, recipientLookup as ad, type BroadcasterFeeSource as b, type BroadcasterQuote as c, BroadcasterRpcError as d, type BroadcasterStatus as e, type BroadcasterTransport as f, type BroadcasterTrust as g, type CreateCreditPreparation as h, type FundingSigner as i, type FundingSource as j, type FundingTypedData as k, type GasBenchmarkDeployment as l, type GasBenchmarkProfile as m, type GasBenchmarkSample as n, type GasBenchmarkShape as o, type GasReference as p, type NoteOutputContext as q, type NoteOutputExecutionOptions as r, type NoteOutputRecipient as s, type SignedBroadcasterQuote as t, type TransactionExecution as u, type TransactionProveOptions as v, type TransferPreparation as w, broadcasterQuoteDomain as x, broadcasterQuoteTypes as y, broadcasterRequestHash as z };

package/dist/broadcaster-preparation-RMWQFYNL.js

@@ -0,0 +1,11 @@
+import {
+  prepareBroadcasterPlan,
+  prepareIntent
+} from "./chunk-GTPUYPQL.js";
+import "./chunk-ITTGBIG2.js";
+import "./chunk-XHKQ2BO2.js";
+export {
+  prepareBroadcasterPlan,
+  prepareIntent
+};
+//# sourceMappingURL=broadcaster-preparation-RMWQFYNL.js.map

package/dist/broadcaster-preparation-UGOTO4SX.cjs

@@ -0,0 +1,11 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkLOU7AP2Bcjs = require('./chunk-LOU7AP2B.cjs');
+require('./chunk-J2JH6HIG.cjs');
+require('./chunk-7F7ZZW3L.cjs');
+
+
+
+exports.prepareBroadcasterPlan = _chunkLOU7AP2Bcjs.prepareBroadcasterPlan; exports.prepareIntent = _chunkLOU7AP2Bcjs.prepareIntent;
+//# sourceMappingURL=broadcaster-preparation-UGOTO4SX.cjs.map

package/dist/broadcaster-preparation-UGOTO4SX.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/invisi-sdk-ts/invisi-sdk-ts/packages/sdk/dist/broadcaster-preparation-UGOTO4SX.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACF,wDAA6B;AAC7B,gCAA6B;AAC7B,gCAA6B;AAC7B;AACE;AACA;AACF,mIAAC","file":"/home/runner/work/invisi-sdk-ts/invisi-sdk-ts/packages/sdk/dist/broadcaster-preparation-UGOTO4SX.cjs"}