@tokenops/sdk 2.0.0-alpha.3 → 2.0.0-alpha.4

package/dist/fhe-airdrop/types.d.ts

@@ -1,4 +1,5 @@
 import type { Address, Hex } from "viem";
+import type { MinedWrite, PendingWrite } from "../core/pending.js";
 import type { DedupMode, DeploymentMode } from "./constants.js";
 /**
  * Create-time fields shared by both variants. There is deliberately no `admin`
@@ -34,6 +35,27 @@ export interface CommonAirdropParams {
      */
     maxAcceptedGasFee: bigint;
 }
+/**
+ * The three values a create commits to. The factory reverts before consuming the salt
+ * when any of them differs from what it would actually deploy (`PredictionMismatch`,
+ * `ManagerImplementationMismatch`, `ComplianceDelegateMismatch`), so a rotation between
+ * quote and send can never produce an instance the creator did not plan for.
+ *
+ * Every field is literal: the zero address never means "skip". A zero
+ * `complianceDelegate` means "I expect the manager clone to carry no platform
+ * delegation", which is what the factory resolves when the creator's effective
+ * compliance policy is OFF.
+ *
+ * @alpha
+ */
+export interface CreateCommitments {
+    /** Where the instance must land - what `predict*AirdropAddress` returned. */
+    airdrop: Address;
+    /** The manager implementation the compliance clone must be made from - `factory.complianceManagerImpl()`. */
+    complianceManagerImpl: Address;
+    /** The platform delegate the clone must be wired with, or zero under an OFF policy - `factory.resolveComplianceDelegate(creator)`. */
+    complianceDelegate: Address;
+}
 /** @alpha */
 export interface EcdsaAirdropParams {
     common: CommonAirdropParams;
@@ -47,6 +69,18 @@ export interface MerkleAirdropParams {
     merkleRoot: Hex;
     isMerkleRootMutable: boolean;
 }
+/**
+ * A variant tag paired with that variant's params, so the two cannot be mismatched.
+ *
+ * @alpha
+ */
+export type AirdropVariantParams = {
+    variant: "ecdsa";
+    params: EcdsaAirdropParams;
+} | {
+    variant: "merkle";
+    params: MerkleAirdropParams;
+};
 /**
  * Arguments shared by both `factory.createEcdsaAirdrop` / `createMerkleAirdrop` entrypoints.
  *
@@ -56,12 +90,62 @@ export interface CreateAirdropArgs<P> {
     params: P;
     mode: DeploymentMode;
     userSalt: Hex;
+    /**
+     * Commitments to pin instead of quoting fresh at send time. Anything omitted is read
+     * from the factory just before the transaction.
+     *
+     * Creating from a {@link PlannedCampaign}? Pass it as `plan` on the Merkle creates
+     * ({@link CreateMerkleAirdropArgs.plan}), which pins `airdrop` for you. Pinning
+     * `{ airdrop: plan.predictedAddress }` here by hand is the lower-level equivalent: the
+     * plan's leaves are bound to that address, and a fresh prediction after an
+     * implementation rotation would commit to a different one.
+     */
+    expected?: Partial<CreateCommitments> | undefined;
+}
+/**
+ * Create arguments for the Merkle variant: the shared shape plus the plan a create may realise.
+ *
+ * @alpha
+ */
+export interface CreateMerkleAirdropArgs extends CreateAirdropArgs<MerkleAirdropParams> {
+    /**
+     * The {@link PlannedCampaign} this create realises. Supplying it pins
+     * `expected.airdrop` to `plan.predictedAddress`, requires `params.merkleRoot`
+     * to equal `plan.root`, and refuses the send when the factory's live Merkle
+     * init-code hash no longer equals `plan.initCodeHashAfter`
+     * ({@link PredictionDriftError}). An `expected.airdrop` given alongside must
+     * equal `plan.predictedAddress`; the other two `expected` fields are passed
+     * through unchanged.
+     */
+    plan?: PlannedCampaign | undefined;
 }
 /** @alpha */
-export interface CreateAirdropResult {
+export interface CreateAirdropResult extends MinedWrite {
+    /** The create's transaction hash; on a pending result, what the wallet returned (from a Safe, the `safeTxHash`). */
     hash: Hex;
     airdrop: Address;
     complianceManager: Address;
+    /** The implementation the compliance clone was made from, as logged by `ComplianceManagerCloned`. */
+    managerImplementation: Address;
+    /** The platform delegate the clone was wired with; zero when the creator's policy was OFF. */
+    complianceDelegate: Address;
+}
+/**
+ * What a create returns with `waitForReceipt: false` (`ReceiptMode`): the same fields as
+ * {@link CreateAirdropResult}, taken from the {@link CreateCommitments} the create was sent
+ * with rather than from a receipt. `hash` is what the wallet returned; from a Safe, the
+ * `safeTxHash`, not the hash of the transaction that eventually executes.
+ *
+ * The factory reverts unless the instance lands at `commitments.airdrop` and the clone is made
+ * from `commitments.complianceManagerImpl` and wired with `commitments.complianceDelegate`, so
+ * once owners co-sign and the transaction executes, those are the addresses its logs report.
+ * Confirm by reading `ConfidentialAirdropCreated` and `ComplianceManagerCloned` from the
+ * executed transaction, or `isAirdrop(airdrop)` on the factory. If that transaction never
+ * executes, no instance exists at `airdrop`.
+ *
+ * @alpha
+ */
+export interface PendingCreateAirdropResult extends Omit<CreateAirdropResult, "pending">, PendingWrite {
 }
 /**
  * One recipient's committed allocation, keyed for `CampaignEntry.merkleProof` construction.
@@ -75,25 +159,17 @@ export interface CampaignRecipient {
     cumulativeTotal: bigint;
 }
 /**
- * One recipient's encrypted, proof-bearing claim input — everything `merkle.claim` needs.
+ * One recipient's encrypted, proof-bearing claim input - everything `merkle.claim` needs.
  *
- * Carries TWO addresses because the contract keys two different things on them:
- * `account` selects the leaf and the cumulative accounting, `boundTo` is who the
- * coprocessor will accept as the sender. They are equal on a self-claim campaign
- * and differ on a relayed one.
+ * `account` is the claim identity: whose leaf this is, whose delivered total advances, and
+ * where payout defaults. The handle and proof are bound to `(instance, instance)`, so ANY
+ * address may submit the entry: the recipient, a relayer, or a stranger. Payout always goes
+ * to `account` unless `account` itself passes `to`.
  *
  * @alpha
  */
 export interface CampaignEntry {
-    /** The claim identity: whose leaf this is, whose delivered total advances, and where payout defaults. */
     account: Address;
-    /**
-     * The only address that can submit this entry. The FHE input proof is bound to
-     * `(instance, boundTo)`, so any other sender is rejected by the coprocessor —
-     * a leaf cannot be re-pointed at a different submitter without re-encrypting,
-     * which changes the handle and therefore the root.
-     */
-    boundTo: Address;
     handle: Hex;
     inputProof: Hex;
     merkleProof: readonly Hex[];
@@ -103,3 +179,22 @@ export interface BuiltCampaign {
     root: Hex;
     entries: readonly CampaignEntry[];
 }
+/**
+ * A campaign built against a not-yet-deployed instance, plus the evidence needed to trust the prediction.
+ *
+ * Create it by passing the plan itself as `plan` to `createMerkleAirdrop` /
+ * `createAndFundMerkleAirdrop`, with `merkleRoot: plan.root` in `params`. Every
+ * entry is bound to `predictedAddress`, so the create pins it, refuses a root
+ * that differs from `root`, and refuses to send once the factory's Merkle
+ * implementation has moved since the plan was taken.
+ *
+ * @alpha
+ */
+export interface PlannedCampaign extends BuiltCampaign {
+    /** Where `createMerkleAirdrop({ mode, userSalt })` from `creator` will land. Every entry is bound to this address. */
+    predictedAddress: Address;
+    /** The factory's Merkle init-code hash read BEFORE the address was predicted. */
+    initCodeHashBefore: Hex;
+    /** The same hash read AFTER. Always equal to `initCodeHashBefore` on a returned plan - a difference throws instead. */
+    initCodeHashAfter: Hex;
+}

package/dist/fhe-disperse/errors.d.ts

@@ -49,10 +49,10 @@ export declare class SubwalletsNotApprovedError extends TokenOpsSdkError {
     });
 }
 /**
- * Direct-mode disperse: the sender has not approved the singleton as an
- * ERC-7984 operator on the token, so `disperseConfidentialTokenDirect` would
+ * The sender has not approved the singleton as an ERC-7984 operator on the
+ * token. Every disperse mode pulls from the sender, so any of them would
  * revert with the raw `ERC7984UnauthorizedSpender` selector (`0x79f2cb38`).
- * Surfaced by `preflightDisperse` in `direct` mode.
+ * Surfaced by `preflightDisperse` in every mode.
  *
  * Remediation: call `setOperator()` / `ensureOperator()` (exported from
  * `@tokenops/sdk/fhe`) with the singleton address before dispersing.

package/dist/fhe-disperse/index.cjs

@@ -1,13 +1,13 @@
 'use strict';
 
-var chunkIEKTGJ4J_cjs = require('../chunk-IEKTGJ4J.cjs');
+var chunkS47IBDTA_cjs = require('../chunk-S47IBDTA.cjs');
 var chunkKFRDLKMA_cjs = require('../chunk-KFRDLKMA.cjs');
 require('../chunk-TEBM66WA.cjs');
 require('../chunk-FAXIIH5R.cjs');
 var chunkFWHYQZ5E_cjs = require('../chunk-FWHYQZ5E.cjs');
-require('../chunk-UG5RKLU2.cjs');
+require('../chunk-SUYBAF27.cjs');
 require('../chunk-MVDQMV25.cjs');
-require('../chunk-PG3WXT3K.cjs');
+require('../chunk-YAL6JSAZ.cjs');
 require('../chunk-JK4XMMKM.cjs');
 require('../chunk-66IHPTOK.cjs');
 var chunk67OV5CX2_cjs = require('../chunk-67OV5CX2.cjs');
@@ -17,79 +17,79 @@ require('../chunk-VJKZWYYJ.cjs');
 
 Object.defineProperty(exports, "AlreadyRegisteredError", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.AlreadyRegisteredError; }
+  get: function () { return chunkS47IBDTA_cjs.AlreadyRegisteredError; }
 });
 Object.defineProperty(exports, "ConfidentialDisperseClient", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.ConfidentialDisperseClient; }
+  get: function () { return chunkS47IBDTA_cjs.ConfidentialDisperseClient; }
 });
 Object.defineProperty(exports, "DEFAULT_ADMIN_ROLE", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.DEFAULT_ADMIN_ROLE; }
+  get: function () { return chunkS47IBDTA_cjs.DEFAULT_ADMIN_ROLE; }
 });
 Object.defineProperty(exports, "DisperseEncryptedReserveNotGrantedError", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.DisperseEncryptedReserveNotGrantedError; }
+  get: function () { return chunkS47IBDTA_cjs.DisperseEncryptedReserveNotGrantedError; }
 });
 Object.defineProperty(exports, "DisperseSubwalletNotFoundError", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.DisperseSubwalletNotFoundError; }
+  get: function () { return chunkS47IBDTA_cjs.DisperseSubwalletNotFoundError; }
 });
 Object.defineProperty(exports, "FEE_COLLECTOR_ROLE", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.FEE_COLLECTOR_ROLE; }
+  get: function () { return chunkS47IBDTA_cjs.FEE_COLLECTOR_ROLE; }
 });
 Object.defineProperty(exports, "FEE_MANAGER_ROLE", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.FEE_MANAGER_ROLE; }
+  get: function () { return chunkS47IBDTA_cjs.FEE_MANAGER_ROLE; }
 });
 Object.defineProperty(exports, "NotRegisteredError", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.NotRegisteredError; }
+  get: function () { return chunkS47IBDTA_cjs.NotRegisteredError; }
 });
 Object.defineProperty(exports, "PAUSER_ROLE", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.PAUSER_ROLE; }
+  get: function () { return chunkS47IBDTA_cjs.PAUSER_ROLE; }
 });
 Object.defineProperty(exports, "SingletonNotApprovedError", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.SingletonNotApprovedError; }
+  get: function () { return chunkS47IBDTA_cjs.SingletonNotApprovedError; }
 });
 Object.defineProperty(exports, "SubwalletsNotApprovedError", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.SubwalletsNotApprovedError; }
+  get: function () { return chunkS47IBDTA_cjs.SubwalletsNotApprovedError; }
 });
 Object.defineProperty(exports, "WITHDRAWER_ROLE", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.WITHDRAWER_ROLE; }
+  get: function () { return chunkS47IBDTA_cjs.WITHDRAWER_ROLE; }
 });
 Object.defineProperty(exports, "computeSubtotals", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.computeSubtotals; }
+  get: function () { return chunkS47IBDTA_cjs.computeSubtotals; }
 });
 Object.defineProperty(exports, "createConfidentialDisperseClient", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.createConfidentialDisperseClient; }
+  get: function () { return chunkS47IBDTA_cjs.createConfidentialDisperseClient; }
 });
 Object.defineProperty(exports, "disperseConfidentialAbi", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.disperseConfidentialAbi; }
+  get: function () { return chunkS47IBDTA_cjs.disperseConfidentialAbi; }
 });
 Object.defineProperty(exports, "disperseWalletAbi", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.disperseWalletAbi; }
+  get: function () { return chunkS47IBDTA_cjs.disperseWalletAbi; }
 });
 Object.defineProperty(exports, "encryptUint64", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.encryptUint64; }
+  get: function () { return chunkS47IBDTA_cjs.encryptUint64; }
 });
 Object.defineProperty(exports, "encryptUint64Batch", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.encryptUint64Batch; }
+  get: function () { return chunkS47IBDTA_cjs.encryptUint64Batch; }
 });
 Object.defineProperty(exports, "resolveEncryptor", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.resolveEncryptor; }
+  get: function () { return chunkS47IBDTA_cjs.resolveEncryptor; }
 });
 Object.defineProperty(exports, "ERC7984_OPERATOR_MAX_DEADLINE", {
   enumerable: true,

package/dist/fhe-disperse/index.d.cts

@@ -1,7 +1,7 @@
 export { ConfidentialDisperseClient, createConfidentialDisperseClient, computeSubtotals, type ConfidentialDisperseClientConfig, } from "./singleton.js";
 export { encryptUint64, encryptUint64Batch, resolveEncryptor, type Encryptor, type EncryptorSource, type EncryptUint64Args, type EncryptUint64BatchArgs, type FheValueInput, } from "./encryption.js";
 export { setOperator, revokeOperator, ERC7984_OPERATOR_MAX_DEADLINE, type SetOperatorArgs, type RevokeOperatorArgs, } from "../fhe/operators.js";
-export { DisperseSubwalletNotFoundError, DisperseEncryptedReserveNotGrantedError, type BatchDiscloseHandlesArgs, type BatchLimits, type CalculateFeeArgs, type CalculatedFee, type CustomFee, type DiscloseHandleArgs, type DisclosureResult, type DisperseArgs, type DisperseDistribution, type DisperseMode, type DisperseResult, type EncryptedInput, type EncryptedInputs, type EncryptedViewResult, type FeeConfig, type GetEncryptedFeeReserveArgs, type PreflightDisperseArgs, type PreflightReport, type RecipientCheck, type RegisterResult, type SubwalletApprovalState, type UserFees, type WithdrawTokenFeeResult, } from "./types.js";
+export { DisperseSubwalletNotFoundError, DisperseEncryptedReserveNotGrantedError, type BatchDiscloseHandlesArgs, type BatchLimits, type CalculateFeeArgs, type CalculatedFee, type CustomFee, type DiscloseHandleArgs, type DisclosureResult, type DisperseArgs, type DisperseDistribution, type DisperseMode, type DisperseResult, type EncryptedInput, type EncryptedInputs, type EncryptedViewResult, type FeeConfig, type GetEncryptedFeeReserveArgs, type PendingDisperseResult, type PendingRegisterResult, type PendingWithdrawTokenFeeResult, type PreflightDisperseArgs, type PreflightReport, type RecipientCheck, type RegisterArgs, type RegisterResult, type SubwalletApprovalState, type UserFees, type WithdrawTokenFeeArgs, type WithdrawTokenFeeResult, } from "./types.js";
 export { disperseConfidentialAbi, disperseWalletAbi } from "./abis/index.js";
 export { erc7984OperatorAbi } from "../fhe/erc7984-abi.js";
 export declare const FEE_COLLECTOR_ROLE: "0x2dca0f5ce7e75a4b43fe2b0d6f5d0b7a2bf92ecf89f8f0aa17b8308b67038821";
@@ -11,4 +11,5 @@ export declare const WITHDRAWER_ROLE: "0x10dac8c06a04bec0b551627dad28bc00d6516b0
 export declare const DEFAULT_ADMIN_ROLE: "0x0000000000000000000000000000000000000000000000000000000000000000";
 export { TokenOpsSdkError, isTokenOpsSdkError, DeploymentAddressUnavailableError, UnsupportedChainError, MissingAccountError, MissingClientError, MissingEncryptorError, MissingPublicClientError, MissingWalletClientError, InvalidArgumentError, ReceiptEventAmbiguousError, ReceiptEventNotFoundError, TokenOpsValidationError, ContractRevertError, TokenOpsContractError, PausedError, AccessDeniedError, OperatorNotApprovedError, InsufficientFeeError, InsufficientBalanceError, BatchTooLargeError, FeatureDisabledError, TransferFailedError, FheHandleNotAllowedError, AlreadyInitializedError, ReentrancyError, InvalidSignatureError, WalletRejectedError, WalletChainMismatchError, NetworkError, InsufficientGasFundsError, UnknownWriteFailureError, UserRejectedSignatureError, SigningFailedError, RelayerUnreachableError, EncryptionFailedError, DecryptionFailedError, UserDecryptNotAllowedError, type DeploymentAddressUnavailableReason, type TokenOpsSdkErrorCode, } from "../core/errors.js";
 export { type PreflightResult } from "../core/preflight.js";
+export type { MinedWrite, PendingWrite, ReceiptMode } from "../core/pending.js";
 export { NotRegisteredError, AlreadyRegisteredError, SubwalletsNotApprovedError, SingletonNotApprovedError, } from "./errors.js";

package/dist/fhe-disperse/index.d.ts

@@ -1,7 +1,7 @@
 export { ConfidentialDisperseClient, createConfidentialDisperseClient, computeSubtotals, type ConfidentialDisperseClientConfig, } from "./singleton.js";
 export { encryptUint64, encryptUint64Batch, resolveEncryptor, type Encryptor, type EncryptorSource, type EncryptUint64Args, type EncryptUint64BatchArgs, type FheValueInput, } from "./encryption.js";
 export { setOperator, revokeOperator, ERC7984_OPERATOR_MAX_DEADLINE, type SetOperatorArgs, type RevokeOperatorArgs, } from "../fhe/operators.js";
-export { DisperseSubwalletNotFoundError, DisperseEncryptedReserveNotGrantedError, type BatchDiscloseHandlesArgs, type BatchLimits, type CalculateFeeArgs, type CalculatedFee, type CustomFee, type DiscloseHandleArgs, type DisclosureResult, type DisperseArgs, type DisperseDistribution, type DisperseMode, type DisperseResult, type EncryptedInput, type EncryptedInputs, type EncryptedViewResult, type FeeConfig, type GetEncryptedFeeReserveArgs, type PreflightDisperseArgs, type PreflightReport, type RecipientCheck, type RegisterResult, type SubwalletApprovalState, type UserFees, type WithdrawTokenFeeResult, } from "./types.js";
+export { DisperseSubwalletNotFoundError, DisperseEncryptedReserveNotGrantedError, type BatchDiscloseHandlesArgs, type BatchLimits, type CalculateFeeArgs, type CalculatedFee, type CustomFee, type DiscloseHandleArgs, type DisclosureResult, type DisperseArgs, type DisperseDistribution, type DisperseMode, type DisperseResult, type EncryptedInput, type EncryptedInputs, type EncryptedViewResult, type FeeConfig, type GetEncryptedFeeReserveArgs, type PendingDisperseResult, type PendingRegisterResult, type PendingWithdrawTokenFeeResult, type PreflightDisperseArgs, type PreflightReport, type RecipientCheck, type RegisterArgs, type RegisterResult, type SubwalletApprovalState, type UserFees, type WithdrawTokenFeeArgs, type WithdrawTokenFeeResult, } from "./types.js";
 export { disperseConfidentialAbi, disperseWalletAbi } from "./abis/index.js";
 export { erc7984OperatorAbi } from "../fhe/erc7984-abi.js";
 export declare const FEE_COLLECTOR_ROLE: "0x2dca0f5ce7e75a4b43fe2b0d6f5d0b7a2bf92ecf89f8f0aa17b8308b67038821";
@@ -11,4 +11,5 @@ export declare const WITHDRAWER_ROLE: "0x10dac8c06a04bec0b551627dad28bc00d6516b0
 export declare const DEFAULT_ADMIN_ROLE: "0x0000000000000000000000000000000000000000000000000000000000000000";
 export { TokenOpsSdkError, isTokenOpsSdkError, DeploymentAddressUnavailableError, UnsupportedChainError, MissingAccountError, MissingClientError, MissingEncryptorError, MissingPublicClientError, MissingWalletClientError, InvalidArgumentError, ReceiptEventAmbiguousError, ReceiptEventNotFoundError, TokenOpsValidationError, ContractRevertError, TokenOpsContractError, PausedError, AccessDeniedError, OperatorNotApprovedError, InsufficientFeeError, InsufficientBalanceError, BatchTooLargeError, FeatureDisabledError, TransferFailedError, FheHandleNotAllowedError, AlreadyInitializedError, ReentrancyError, InvalidSignatureError, WalletRejectedError, WalletChainMismatchError, NetworkError, InsufficientGasFundsError, UnknownWriteFailureError, UserRejectedSignatureError, SigningFailedError, RelayerUnreachableError, EncryptionFailedError, DecryptionFailedError, UserDecryptNotAllowedError, type DeploymentAddressUnavailableReason, type TokenOpsSdkErrorCode, } from "../core/errors.js";
 export { type PreflightResult } from "../core/preflight.js";
+export type { MinedWrite, PendingWrite, ReceiptMode } from "../core/pending.js";
 export { NotRegisteredError, AlreadyRegisteredError, SubwalletsNotApprovedError, SingletonNotApprovedError, } from "./errors.js";

package/dist/fhe-disperse/index.js

@@ -1,11 +1,11 @@
-export { AlreadyRegisteredError, ConfidentialDisperseClient, DEFAULT_ADMIN_ROLE, DisperseEncryptedReserveNotGrantedError, DisperseSubwalletNotFoundError, FEE_COLLECTOR_ROLE, FEE_MANAGER_ROLE, NotRegisteredError, PAUSER_ROLE, SingletonNotApprovedError, SubwalletsNotApprovedError, WITHDRAWER_ROLE, computeSubtotals, createConfidentialDisperseClient, disperseConfidentialAbi, disperseWalletAbi, encryptUint64, encryptUint64Batch, resolveEncryptor } from '../chunk-PK6Q6J5F.js';
+export { AlreadyRegisteredError, ConfidentialDisperseClient, DEFAULT_ADMIN_ROLE, DisperseEncryptedReserveNotGrantedError, DisperseSubwalletNotFoundError, FEE_COLLECTOR_ROLE, FEE_MANAGER_ROLE, NotRegisteredError, PAUSER_ROLE, SingletonNotApprovedError, SubwalletsNotApprovedError, WITHDRAWER_ROLE, computeSubtotals, createConfidentialDisperseClient, disperseConfidentialAbi, disperseWalletAbi, encryptUint64, encryptUint64Batch, resolveEncryptor } from '../chunk-CHGY6B7L.js';
 export { ERC7984_OPERATOR_MAX_DEADLINE, revokeOperator, setOperator } from '../chunk-4TSDNZQ3.js';
 import '../chunk-WMACINXO.js';
 import '../chunk-ZWXJTBZO.js';
 export { erc7984OperatorAbi } from '../chunk-7VELUOMI.js';
-import '../chunk-NWFMBLSQ.js';
+import '../chunk-7KY4K4PH.js';
 import '../chunk-4RAAATVY.js';
-import '../chunk-6HCT4QIX.js';
+import '../chunk-GHGF65LN.js';
 import '../chunk-ZA673I3O.js';
 import '../chunk-KWFFIJYX.js';
 export { AccessDeniedError, AlreadyInitializedError, BatchTooLargeError, ContractRevertError, DecryptionFailedError, DeploymentAddressUnavailableError, EncryptionFailedError, FeatureDisabledError, FheHandleNotAllowedError, InsufficientBalanceError, InsufficientFeeError, InsufficientGasFundsError, InvalidArgumentError, InvalidSignatureError, MissingAccountError, MissingClientError, MissingEncryptorError, MissingPublicClientError, MissingWalletClientError, NetworkError, OperatorNotApprovedError, PausedError, ReceiptEventAmbiguousError, ReceiptEventNotFoundError, ReentrancyError, RelayerUnreachableError, SigningFailedError, TokenOpsContractError, TokenOpsSdkError, TokenOpsValidationError, TransferFailedError, UnknownWriteFailureError, UnsupportedChainError, UserDecryptNotAllowedError, UserRejectedSignatureError, WalletChainMismatchError, WalletRejectedError, isTokenOpsSdkError } from '../chunk-QBJ7O2B4.js';

package/dist/fhe-disperse/react/index.cjs

@@ -1,15 +1,15 @@
 'use strict';
 
-var chunkIEKTGJ4J_cjs = require('../../chunk-IEKTGJ4J.cjs');
+var chunkS47IBDTA_cjs = require('../../chunk-S47IBDTA.cjs');
 var chunk7AFPOE7N_cjs = require('../../chunk-7AFPOE7N.cjs');
 require('../../chunk-ZQUE2B3Q.cjs');
 require('../../chunk-KFRDLKMA.cjs');
 require('../../chunk-TEBM66WA.cjs');
 require('../../chunk-FAXIIH5R.cjs');
 require('../../chunk-FWHYQZ5E.cjs');
-require('../../chunk-UG5RKLU2.cjs');
+require('../../chunk-SUYBAF27.cjs');
 require('../../chunk-MVDQMV25.cjs');
-var chunkPG3WXT3K_cjs = require('../../chunk-PG3WXT3K.cjs');
+var chunkYAL6JSAZ_cjs = require('../../chunk-YAL6JSAZ.cjs');
 require('../../chunk-JK4XMMKM.cjs');
 require('../../chunk-66IHPTOK.cjs');
 var chunk67OV5CX2_cjs = require('../../chunk-67OV5CX2.cjs');
@@ -23,7 +23,7 @@ var FHE_DISPERSE_NAMESPACE = "fhe-disperse";
 function tryResolveSingletonAddress(override, chainId) {
   if (override) return override;
   if (chainId === void 0) return void 0;
-  return chunkPG3WXT3K_cjs.getFheDisperseSingletonAddress(chainId);
+  return chunkYAL6JSAZ_cjs.getFheDisperseSingletonAddress(chainId);
 }
 function useMemoDisperseClient(opts = {}) {
   const publicClient = wagmi.usePublicClient({ chainId: opts.chainId });
@@ -36,14 +36,14 @@ function useMemoDisperseClient(opts = {}) {
   const client = react.useMemo(() => {
     if (!publicClient) return void 0;
     if (!resolvedAddress) return void 0;
-    return chunkIEKTGJ4J_cjs.createConfidentialDisperseClient({
+    return chunkS47IBDTA_cjs.createConfidentialDisperseClient({
       publicClient,
       ...walletClient ? { walletClient } : {},
       address: resolvedAddress,
       ...chainId !== void 0 ? { chainId } : {},
       // Lazy — invoked per-encryption inside the headless client. Picks up
       // whichever EncryptorSource the consumer last passed in.
-      encryptor: () => chunkIEKTGJ4J_cjs.resolveEncryptor(encryptorSourceRef.current),
+      encryptor: () => chunkS47IBDTA_cjs.resolveEncryptor(encryptorSourceRef.current),
       ...opts.aclAddress ? { aclAddress: opts.aclAddress } : {}
     });
   }, [publicClient, walletClient, resolvedAddress, chainId, opts.aclAddress]);
@@ -66,7 +66,7 @@ function computeSingletonResolutionError(override, chainId) {
       clientLabel: "ConfidentialDisperseClient"
     });
   }
-  const resolved = chunkPG3WXT3K_cjs.getFheDisperseSingletonAddress(chainId);
+  const resolved = chunkYAL6JSAZ_cjs.getFheDisperseSingletonAddress(chainId);
   if (!resolved) {
     return new chunk67OV5CX2_cjs.DeploymentAddressUnavailableError({
       reason: "registry-not-deployed",
@@ -468,17 +468,19 @@ function useWithdrawTokenFee(options = {}) {
           token: token2,
           to: to2,
           encryptedInput,
-          ...account2 !== void 0 ? { account: account2 } : {}
+          ...account2 !== void 0 ? { account: account2 } : {},
+          waitForReceipt: args.waitForReceipt
         });
       }
       const { token, to, amount, encryptor: encryptorSource, account } = args;
-      const eager = encryptorSource ? chunkIEKTGJ4J_cjs.resolveEncryptor(encryptorSource) : void 0;
+      const eager = encryptorSource ? chunkS47IBDTA_cjs.resolveEncryptor(encryptorSource) : void 0;
       return client.withdrawTokenFee({
         token,
         to,
         amount,
         ...eager ? { encryptor: eager } : {},
-        ...account !== void 0 ? { account } : {}
+        ...account !== void 0 ? { account } : {},
+        waitForReceipt: args.waitForReceipt
       });
     }
   });
@@ -524,63 +526,63 @@ function useRevokeRole(options = {}) {
 
 Object.defineProperty(exports, "AlreadyRegisteredError", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.AlreadyRegisteredError; }
+  get: function () { return chunkS47IBDTA_cjs.AlreadyRegisteredError; }
 });
 Object.defineProperty(exports, "DEFAULT_ADMIN_ROLE", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.DEFAULT_ADMIN_ROLE; }
+  get: function () { return chunkS47IBDTA_cjs.DEFAULT_ADMIN_ROLE; }
 });
 Object.defineProperty(exports, "DisperseEncryptedReserveNotGrantedError", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.DisperseEncryptedReserveNotGrantedError; }
+  get: function () { return chunkS47IBDTA_cjs.DisperseEncryptedReserveNotGrantedError; }
 });
 Object.defineProperty(exports, "DisperseSubwalletNotFoundError", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.DisperseSubwalletNotFoundError; }
+  get: function () { return chunkS47IBDTA_cjs.DisperseSubwalletNotFoundError; }
 });
 Object.defineProperty(exports, "FEE_COLLECTOR_ROLE", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.FEE_COLLECTOR_ROLE; }
+  get: function () { return chunkS47IBDTA_cjs.FEE_COLLECTOR_ROLE; }
 });
 Object.defineProperty(exports, "FEE_MANAGER_ROLE", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.FEE_MANAGER_ROLE; }
+  get: function () { return chunkS47IBDTA_cjs.FEE_MANAGER_ROLE; }
 });
 Object.defineProperty(exports, "NotRegisteredError", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.NotRegisteredError; }
+  get: function () { return chunkS47IBDTA_cjs.NotRegisteredError; }
 });
 Object.defineProperty(exports, "PAUSER_ROLE", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.PAUSER_ROLE; }
+  get: function () { return chunkS47IBDTA_cjs.PAUSER_ROLE; }
 });
 Object.defineProperty(exports, "SingletonNotApprovedError", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.SingletonNotApprovedError; }
+  get: function () { return chunkS47IBDTA_cjs.SingletonNotApprovedError; }
 });
 Object.defineProperty(exports, "SubwalletsNotApprovedError", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.SubwalletsNotApprovedError; }
+  get: function () { return chunkS47IBDTA_cjs.SubwalletsNotApprovedError; }
 });
 Object.defineProperty(exports, "WITHDRAWER_ROLE", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.WITHDRAWER_ROLE; }
+  get: function () { return chunkS47IBDTA_cjs.WITHDRAWER_ROLE; }
 });
 Object.defineProperty(exports, "computeSubtotals", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.computeSubtotals; }
+  get: function () { return chunkS47IBDTA_cjs.computeSubtotals; }
 });
 Object.defineProperty(exports, "encryptUint64", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.encryptUint64; }
+  get: function () { return chunkS47IBDTA_cjs.encryptUint64; }
 });
 Object.defineProperty(exports, "encryptUint64Batch", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.encryptUint64Batch; }
+  get: function () { return chunkS47IBDTA_cjs.encryptUint64Batch; }
 });
 Object.defineProperty(exports, "resolveEncryptor", {
   enumerable: true,
-  get: function () { return chunkIEKTGJ4J_cjs.resolveEncryptor; }
+  get: function () { return chunkS47IBDTA_cjs.resolveEncryptor; }
 });
 Object.defineProperty(exports, "useEnsureOperator", {
   enumerable: true,

package/dist/fhe-disperse/react/index.d.cts

@@ -76,9 +76,10 @@ export { FHE_DISPERSE_KEY, FHE_DISPERSE_NAMESPACE } from "./_shared.js";
 export { FEE_COLLECTOR_ROLE, FEE_MANAGER_ROLE, PAUSER_ROLE, WITHDRAWER_ROLE, DEFAULT_ADMIN_ROLE, } from "../index.js";
 export { computeSubtotals, } from "../singleton.js";
 export { encryptUint64, encryptUint64Batch, resolveEncryptor, type Encryptor, type EncryptorSource, type EncryptUint64Args, type EncryptUint64BatchArgs, type FheValueInput, } from "../encryption.js";
-export { DisperseSubwalletNotFoundError, DisperseEncryptedReserveNotGrantedError, type BatchDiscloseHandlesArgs, type BatchLimits, type CalculateFeeArgs, type CalculatedFee, type DiscloseHandleArgs, type DisperseArgs, type DisperseMode, type DisperseResult, type EncryptedInput, type EncryptedInputs, type EncryptedViewResult, type FeeConfig, type GetEncryptedFeeReserveArgs, type PreflightDisperseArgs, type PreflightReport, type RecipientCheck, type RegisterResult, type SubwalletApprovalState, type UserFees, } from "../types.js";
+export { DisperseSubwalletNotFoundError, DisperseEncryptedReserveNotGrantedError, type BatchDiscloseHandlesArgs, type BatchLimits, type CalculateFeeArgs, type CalculatedFee, type DiscloseHandleArgs, type DisperseArgs, type DisperseMode, type DisperseResult, type EncryptedInput, type EncryptedInputs, type EncryptedViewResult, type FeeConfig, type GetEncryptedFeeReserveArgs, type PendingDisperseResult, type PendingRegisterResult, type PendingWithdrawTokenFeeResult, type PreflightDisperseArgs, type PreflightReport, type RecipientCheck, type RegisterResult, type SubwalletApprovalState, type UserFees, type WithdrawTokenFeeResult, } from "../types.js";
 export { TokenOpsSdkError, isTokenOpsSdkError, DeploymentAddressUnavailableError, UnsupportedChainError, MissingAccountError, MissingClientError, MissingEncryptorError, MissingPublicClientError, MissingWalletClientError, InvalidArgumentError, ReceiptEventAmbiguousError, ReceiptEventNotFoundError, ContractRevertError, PausedError, AccessDeniedError, OperatorNotApprovedError, InsufficientFeeError, InsufficientBalanceError, BatchTooLargeError, FeatureDisabledError, TransferFailedError, FheHandleNotAllowedError, AlreadyInitializedError, ReentrancyError, InvalidSignatureError, WalletRejectedError, WalletChainMismatchError, NetworkError, InsufficientGasFundsError, UnknownWriteFailureError, UserRejectedSignatureError, SigningFailedError, RelayerUnreachableError, EncryptionFailedError, DecryptionFailedError, UserDecryptNotAllowedError, type DeploymentAddressUnavailableReason, type TokenOpsSdkErrorCode, } from "../../core/errors.js";
 export { type PreflightResult } from "../../core/preflight.js";
+export type { MinedWrite, PendingWrite, ReceiptMode } from "../../core/pending.js";
 export { NotRegisteredError, AlreadyRegisteredError, SubwalletsNotApprovedError, SingletonNotApprovedError, } from "../errors.js";
 export { useIsOperator, type UseIsOperatorOptions } from "../../fhe/react/useIsOperator.js";
 export { useEnsureOperator, type UseEnsureOperatorOptions, type EnsureOperatorVariables, } from "../../fhe/react/useEnsureOperator.js";

package/dist/fhe-disperse/react/index.d.ts

@@ -76,9 +76,10 @@ export { FHE_DISPERSE_KEY, FHE_DISPERSE_NAMESPACE } from "./_shared.js";
 export { FEE_COLLECTOR_ROLE, FEE_MANAGER_ROLE, PAUSER_ROLE, WITHDRAWER_ROLE, DEFAULT_ADMIN_ROLE, } from "../index.js";
 export { computeSubtotals, } from "../singleton.js";
 export { encryptUint64, encryptUint64Batch, resolveEncryptor, type Encryptor, type EncryptorSource, type EncryptUint64Args, type EncryptUint64BatchArgs, type FheValueInput, } from "../encryption.js";
-export { DisperseSubwalletNotFoundError, DisperseEncryptedReserveNotGrantedError, type BatchDiscloseHandlesArgs, type BatchLimits, type CalculateFeeArgs, type CalculatedFee, type DiscloseHandleArgs, type DisperseArgs, type DisperseMode, type DisperseResult, type EncryptedInput, type EncryptedInputs, type EncryptedViewResult, type FeeConfig, type GetEncryptedFeeReserveArgs, type PreflightDisperseArgs, type PreflightReport, type RecipientCheck, type RegisterResult, type SubwalletApprovalState, type UserFees, } from "../types.js";
+export { DisperseSubwalletNotFoundError, DisperseEncryptedReserveNotGrantedError, type BatchDiscloseHandlesArgs, type BatchLimits, type CalculateFeeArgs, type CalculatedFee, type DiscloseHandleArgs, type DisperseArgs, type DisperseMode, type DisperseResult, type EncryptedInput, type EncryptedInputs, type EncryptedViewResult, type FeeConfig, type GetEncryptedFeeReserveArgs, type PendingDisperseResult, type PendingRegisterResult, type PendingWithdrawTokenFeeResult, type PreflightDisperseArgs, type PreflightReport, type RecipientCheck, type RegisterResult, type SubwalletApprovalState, type UserFees, type WithdrawTokenFeeResult, } from "../types.js";
 export { TokenOpsSdkError, isTokenOpsSdkError, DeploymentAddressUnavailableError, UnsupportedChainError, MissingAccountError, MissingClientError, MissingEncryptorError, MissingPublicClientError, MissingWalletClientError, InvalidArgumentError, ReceiptEventAmbiguousError, ReceiptEventNotFoundError, ContractRevertError, PausedError, AccessDeniedError, OperatorNotApprovedError, InsufficientFeeError, InsufficientBalanceError, BatchTooLargeError, FeatureDisabledError, TransferFailedError, FheHandleNotAllowedError, AlreadyInitializedError, ReentrancyError, InvalidSignatureError, WalletRejectedError, WalletChainMismatchError, NetworkError, InsufficientGasFundsError, UnknownWriteFailureError, UserRejectedSignatureError, SigningFailedError, RelayerUnreachableError, EncryptionFailedError, DecryptionFailedError, UserDecryptNotAllowedError, type DeploymentAddressUnavailableReason, type TokenOpsSdkErrorCode, } from "../../core/errors.js";
 export { type PreflightResult } from "../../core/preflight.js";
+export type { MinedWrite, PendingWrite, ReceiptMode } from "../../core/pending.js";
 export { NotRegisteredError, AlreadyRegisteredError, SubwalletsNotApprovedError, SingletonNotApprovedError, } from "../errors.js";
 export { useIsOperator, type UseIsOperatorOptions } from "../../fhe/react/useIsOperator.js";
 export { useEnsureOperator, type UseEnsureOperatorOptions, type EnsureOperatorVariables, } from "../../fhe/react/useEnsureOperator.js";

package/dist/fhe-disperse/react/index.js

@@ -1,14 +1,14 @@
-import { resolveEncryptor, createConfidentialDisperseClient } from '../../chunk-PK6Q6J5F.js';
-export { AlreadyRegisteredError, DEFAULT_ADMIN_ROLE, DisperseEncryptedReserveNotGrantedError, DisperseSubwalletNotFoundError, FEE_COLLECTOR_ROLE, FEE_MANAGER_ROLE, NotRegisteredError, PAUSER_ROLE, SingletonNotApprovedError, SubwalletsNotApprovedError, WITHDRAWER_ROLE, computeSubtotals, encryptUint64, encryptUint64Batch, resolveEncryptor } from '../../chunk-PK6Q6J5F.js';
+import { resolveEncryptor, createConfidentialDisperseClient } from '../../chunk-CHGY6B7L.js';
+export { AlreadyRegisteredError, DEFAULT_ADMIN_ROLE, DisperseEncryptedReserveNotGrantedError, DisperseSubwalletNotFoundError, FEE_COLLECTOR_ROLE, FEE_MANAGER_ROLE, NotRegisteredError, PAUSER_ROLE, SingletonNotApprovedError, SubwalletsNotApprovedError, WITHDRAWER_ROLE, computeSubtotals, encryptUint64, encryptUint64Batch, resolveEncryptor } from '../../chunk-CHGY6B7L.js';
 export { useEnsureOperator, useIsOperator } from '../../chunk-AXIPOR3C.js';
 import '../../chunk-FT4LNBOS.js';
 import '../../chunk-4TSDNZQ3.js';
 import '../../chunk-WMACINXO.js';
 import '../../chunk-ZWXJTBZO.js';
 import '../../chunk-7VELUOMI.js';
-import '../../chunk-NWFMBLSQ.js';
+import '../../chunk-7KY4K4PH.js';
 import '../../chunk-4RAAATVY.js';
-import { getFheDisperseSingletonAddress } from '../../chunk-6HCT4QIX.js';
+import { getFheDisperseSingletonAddress } from '../../chunk-GHGF65LN.js';
 import '../../chunk-ZA673I3O.js';
 import '../../chunk-KWFFIJYX.js';
 import { MissingClientError, DeploymentAddressUnavailableError } from '../../chunk-QBJ7O2B4.js';
@@ -468,7 +468,8 @@ function useWithdrawTokenFee(options = {}) {
           token: token2,
           to: to2,
           encryptedInput,
-          ...account2 !== void 0 ? { account: account2 } : {}
+          ...account2 !== void 0 ? { account: account2 } : {},
+          waitForReceipt: args.waitForReceipt
         });
       }
       const { token, to, amount, encryptor: encryptorSource, account } = args;
@@ -478,7 +479,8 @@ function useWithdrawTokenFee(options = {}) {
         to,
         amount,
         ...eager ? { encryptor: eager } : {},
-        ...account !== void 0 ? { account } : {}
+        ...account !== void 0 ? { account } : {},
+        waitForReceipt: args.waitForReceipt
       });
     }
   });

package/dist/fhe-disperse/react/useDisperse.d.ts

@@ -1,5 +1,6 @@
 import { type UseMutationResult } from "@tanstack/react-query";
-import { type DisperseArgs, type DisperseResult } from "../types.js";
+import type { ReceiptMode } from "../../core/pending.js";
+import { type DisperseArgs, type DisperseResult, type PendingDisperseResult } from "../types.js";
 import { type DisperseHookOptions } from "./_shared.js";
 /**
  * Disperse confidential tokens to multiple recipients. The SDK validates
@@ -22,6 +23,9 @@ import { type DisperseHookOptions } from "./_shared.js";
  * `() => useZamaSDK().relayer` inline (calls a React hook inside a mutation
  * body, violating the rules of hooks; see CLAUDE.md Pitfall #3).
  *
+ * With `waitForReceipt: false` (Safe / multisig) the mutation resolves to a
+ * {@link PendingDisperseResult}; narrow with `if (data.pending)` before reading `distributions`.
+ *
  * After success, invalidate `useGetFees`, `useHasApprovedSubwallets`, and any
  * downstream token-balance queries owned by the consumer.
  *
@@ -34,4 +38,4 @@ import { type DisperseHookOptions } from "./_shared.js";
  *   disperse.mutate({ token, mode: "direct", recipients, amounts });
  * }
  */
-export declare function useDisperse(options?: DisperseHookOptions): UseMutationResult<DisperseResult, Error, DisperseArgs>;
+export declare function useDisperse(options?: DisperseHookOptions): UseMutationResult<DisperseResult | PendingDisperseResult, Error, DisperseArgs & ReceiptMode>;

package/dist/fhe-disperse/react/useRegister.d.ts

@@ -1,12 +1,17 @@
 import { type UseMutationResult } from "@tanstack/react-query";
 import type { Account, Address } from "viem";
-import { type RegisterResult } from "../types.js";
+import { type PendingRegisterResult, type RegisterResult } from "../types.js";
 import { type DisperseHookOptions } from "./_shared.js";
 export interface UseRegisterArgs {
     /** ERC-7984 token to approve the new subwallets for. */
     token: Address;
     /** Override signer account. Falls back to `walletClient.account`. */
     account?: Account | Address;
+    /**
+     * See `ReceiptMode`. With `false` the mutation resolves to a
+     * {@link PendingRegisterResult}; narrow with `if (data.pending)` before reading `wallets`.
+     */
+    waitForReceipt?: boolean | undefined;
 }
 /**
  * Deploy the caller's dedicated wallet pair via `register(token)` and parse
@@ -35,6 +40,7 @@ export interface UseRegisterArgs {
  * @example
  * const register = useRegister();
  * register.mutate({ token });
- * // register.data → { hash, wallets: [wallet0, wallet1] }
+ * // register.data → { hash, wallets: [wallet0, wallet1] }; with waitForReceipt: false,
+ * // { hash, wallets: undefined, pending: true }
  */
-export declare function useRegister(options?: DisperseHookOptions): UseMutationResult<RegisterResult, Error, UseRegisterArgs>;
+export declare function useRegister(options?: DisperseHookOptions): UseMutationResult<RegisterResult | PendingRegisterResult, Error, UseRegisterArgs>;