@tokenops/sdk 1.5.1 → 2.0.0-alpha.1

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

@@ -0,0 +1,147 @@
+import type { Address, Hex } from "viem";
+import { type TokenOpsSdkError } from "../core/errors.js";
+import type { AirdropBaseClient } from "./airdrop-base.js";
+/**
+ * The on-chain role names this module knows how to grant or revoke.
+ *
+ * @alpha
+ */
+export type RoleName = "DEFAULT_ADMIN_ROLE" | "PAUSER_ROLE" | "WINDOW_ADMIN_ROLE" | "TREASURY_ROLE" | "RESCUER_ROLE" | "DISCLOSURE_ADMIN_ROLE" | "UPGRADER_ROLE" | "MERKLE_ADMIN_ROLE" | "SIGNER_ROLE";
+/**
+ * The roles a campaign creator may hand off after `createEcdsaAirdrop` /
+ * `createMerkleAirdrop`. Every field is optional — pass only the roles you
+ * intend to split.
+ *
+ * `merkleAdmin` only exists on Merkle instances and `signer` only on ECDSA
+ * ones; passing either against the wrong variant is one of
+ * {@link planInstanceRoleSplit}'s three refusals.
+ *
+ * @alpha
+ */
+export interface InstanceRoleAssignment {
+    pauser?: Address;
+    windowAdmin?: Address;
+    treasury?: Address;
+    rescuer?: Address;
+    disclosureAdmin?: Address;
+    upgrader?: Address;
+    merkleAdmin?: Address;
+    signer?: Address;
+    /** Granting this always fails from DEFAULT_ADMIN — see planInstanceRoleSplit. */
+    feeCollector?: Address;
+    /** Transfers DEFAULT_ADMIN_ROLE. Granted first, then revoked from the creator. */
+    admin?: Address;
+}
+/**
+ * One `grantRole`/`revokeRole` transaction {@link grantInstanceRoles} will submit, in order.
+ *
+ * @alpha
+ */
+export interface RoleGrantStep {
+    kind: "grant" | "revoke";
+    role: RoleName;
+    account: Address;
+}
+/**
+ * The outcome of one step from {@link grantInstanceRoles}. Exactly one of
+ * `hash` / `error` is set — never both, never neither. `hash` is set only
+ * once that transaction's receipt has been confirmed with `status ===
+ * "success"`; a transaction that was submitted but mined with a reverted
+ * status is reported as `error`, not `hash`.
+ *
+ * @alpha
+ */
+export interface RoleGrantOutcome {
+    role: string;
+    account: Address;
+    hash?: Hex;
+    error?: TokenOpsSdkError;
+}
+/**
+ * Turn an {@link InstanceRoleAssignment} into an ordered list of
+ * `grantRole`/`revokeRole` steps — a pure function, precisely so its ordering
+ * guarantees are testable without a chain.
+ *
+ * Three requests are refused outright rather than turned into a step that
+ * would only revert on-chain:
+ *
+ * 1. **`feeCollector`.** `FEE_COLLECTOR_ROLE` is self-administered
+ *    (`_setRoleAdmin(FEE_COLLECTOR_ROLE, FEE_COLLECTOR_ROLE)`,
+ *    `ConfidentialAirdropBase.sol:142`) — `DEFAULT_ADMIN_ROLE` cannot grant
+ *    it, only an existing member can, and the campaign creator never is one
+ *    (the factory's collector is seeded instead, `:143`).
+ * 2. **`admin` set to the zero address.** Mirrors the contract's
+ *    unconditional `ZeroAdminGrant` guard (`_grantRole`, `:281`).
+ * 3. **A variant-only role on the wrong campaign** — `merkleAdmin` on an
+ *    ECDSA instance, or `signer` on a Merkle one. Neither role exists there;
+ *    the getter itself would revert.
+ *
+ * `admin`, when present, always produces two steps — grant the new admin,
+ * then revoke `args.caller` — and the revoke is always ORDERED LAST, after
+ * every other step in the plan. `_revokeRole`'s `LastAdmin` floor
+ * (`ConfidentialAirdropBase.sol:261`) blocks removing the sole
+ * `DEFAULT_ADMIN_ROLE` member, so revoking the creator first would strand
+ * every later grant with no admin left to authorize it.
+ *
+ * @throws {@link FeeCollectorSelfAdministeredError} for refusal 1 — a distinct
+ *   condition with a distinct remedy (an existing collector must call
+ *   `grantRole`), so it gets its own type rather than being folded into the
+ *   generic argument error.
+ * @throws {@link InvalidArgumentError} for refusals 2 and 3.
+ *
+ * @alpha
+ */
+export declare function planInstanceRoleSplit(args: {
+    assignment: InstanceRoleAssignment;
+    caller: Address;
+    airdropType: "ecdsa" | "merkle";
+}): RoleGrantStep[];
+/**
+ * Execute an {@link InstanceRoleAssignment} against a live instance:
+ * {@link planInstanceRoleSplit} the steps, then submit them one at a time,
+ * **waiting for each step's receipt before submitting the next.**
+ *
+ * That confirmation is not optional bookkeeping — it is what makes the
+ * `DEFAULT_ADMIN_ROLE` handoff correct. `revokeRole`'s simulate reads
+ * `latest` chain state; if the preceding grant were only submitted and not
+ * yet mined, the revoke would simulate (and the contract would enforce its
+ * `LastAdmin` floor) against a world where the new admin does not exist yet,
+ * reverting a step that should succeed. Confirming first makes each step's
+ * simulate see every effect the plan already committed.
+ *
+ * This makes the executor slower than a fire-and-forget submit loop —
+ * intentionally: correctness of the ordering guarantee in
+ * {@link planInstanceRoleSplit} depends on it.
+ *
+ * **This is several transactions, not one — never atomic.** Each step is
+ * caught individually, so one failing grant or revoke does not abort the
+ * rest; inspect each {@link RoleGrantOutcome} rather than assuming
+ * all-or-nothing. A step whose transaction is submitted but mined with a
+ * reverted status is recorded as a failed outcome (`error` set, not `hash`)
+ * — a submitted-but-reverted transaction is never reported as a success. A
+ * `DEFAULT_ADMIN_ROLE` handoff that fails on the revoke half after the grant
+ * half already landed leaves the instance with TWO admins — not broken, just
+ * not yet what was asked for; re-run with only `assignment.admin` set (and
+ * `revokeFromCreator: true`) to finish it.
+ *
+ * The plan's `caller` and `airdropType` are derived from `airdrop` itself —
+ * the wallet client's default account, and a chain read of `airdropType()` —
+ * so this function's inputs stay limited to what the caller actually chooses.
+ *
+ * @param args.revokeFromCreator When `assignment.admin` is set, whether to
+ *   also revoke the creator's `DEFAULT_ADMIN_ROLE` (the default). Pass `false`
+ *   to grant the new admin only, leaving both addresses as admins — an
+ *   escape hatch for callers not yet ready to give up the creator's access.
+ * @throws {@link FeeCollectorSelfAdministeredError} or {@link InvalidArgumentError} before any
+ *   transaction — but NOT synchronously: the plan is built after an awaited
+ *   `airdropType()` read. See the three refusals on {@link planInstanceRoleSplit}.
+ * @throws {@link MissingWalletClientError} when `airdrop` has no wallet client.
+ * @throws {@link MissingAccountError} when the wallet client has no default account.
+ *
+ * @alpha
+ */
+export declare function grantInstanceRoles(args: {
+    airdrop: AirdropBaseClient;
+    assignment: InstanceRoleAssignment;
+    revokeFromCreator?: boolean;
+}): Promise<RoleGrantOutcome[]>;

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

@@ -1,66 +1,79 @@
-import type { Address } from "viem";
-import type { TokenOpsSdkError } from "../core/errors.js";
-export type { EncryptedInput, EncryptedInputs, EncryptedViewResult } from "../fhe/types.js";
+import type { Address, Hex } from "viem";
+import type { DedupMode, DeploymentMode } from "./constants.js";
 /**
- * Parameters for creating a confidential airdrop.
+ * Create-time fields shared by both variants. There is deliberately no `admin`
+ * field: the factory injects `admin = msg.sender`. Split roles after create
+ * with `grantInstanceRoles` — see `roles.ts`.
  *
- * `startTimestamp` and `endTimestamp` are unix timestamps (uint32). The SDK
- * maps them to the on-chain struct fields `startTime` / `endTime` before
- * encoding — do not pass the on-chain names directly.
+ * @alpha
  */
-export interface AirdropParams {
+export interface CommonAirdropParams {
     token: Address;
-    startTimestamp: number;
-    endTimestamp: number;
+    startTime: number;
+    endTime: number;
     canExtendClaimWindow: boolean;
-    admin: Address;
+    /**
+     * Only valid when `token` is a stock ERC7984ERC20Wrapper: `claimAndUnwrap` burns from the
+     * airdrop instance's pooled wrapper balance, so a hooked or fee-taking wrapper can deliver an
+     * amount the pool balance alone doesn't bound correctly. See {@link NonStockWrapperError}.
+     */
+    unwrappable: boolean;
+    /** Client admin AND client delegate of the compliance clone. Zero means msg.sender. */
+    complianceAdmin: Address;
 }
-/** Custom fee override for a campaign creator. */
-export interface CustomFee {
-    enabled: boolean;
-    gasFee: bigint;
+/** @alpha */
+export interface EcdsaAirdropParams {
+    common: CommonAirdropParams;
+    signer: Address;
+    dedupMode: DedupMode;
+}
+/** @alpha */
+export interface MerkleAirdropParams {
+    common: CommonAirdropParams;
+    /** Zero root is only permitted when `isMerkleRootMutable` is true. */
+    merkleRoot: Hex;
+    isMerkleRootMutable: boolean;
 }
 /**
- * Report returned by `ConfidentialAirdropFactoryClient.preflightCreateAirdrop`.
+ * Arguments shared by both `factory.createEcdsaAirdrop` / `createMerkleAirdrop` entrypoints.
  *
- * Fields:
- * - `isFactoryOperator` — `true` when the creator has approved the factory as
- *   an ERC-7984 operator on `params.token`. Only required when funding in the
- *   same transaction (`createAndFundConfidentialAirdrop` /
- *   `fundConfidentialAirdrop`); `false` also when the token address was
- *   structurally invalid and the read was skipped.
- * - `gasFee` — the per-claim gas fee (wei) the factory will embed into the
- *   clone for this creator: the creator's custom fee when one is enabled,
- *   otherwise `defaultGasFee`. This is the `gasFee` to use for address
- *   prediction and later `fundConfidentialAirdrop` calls.
- * - `predictedAirdrop` — deterministic CREATE2 clone address for
- *   `(params, userSalt, creator, gasFee)`. `undefined` when `userSalt` was not
- *   supplied or the params were structurally invalid.
- * - `alreadyDeployed` — `true` when bytecode already exists at
- *   `predictedAirdrop` (a repeat create with the same salt would revert).
- *   `undefined` when `predictedAirdrop` is `undefined`.
- * - `ready` — `true` when no blockers were detected.
- * - `blockers` — human-readable blocker descriptions. Empty when
- *   `ready === true`.
- * - `blockerErrors` — the same blockers as typed `TokenOpsSdkError`s, index-
- *   aligned with `blockers`. Branch on `error.code` to render UI.
+ * @alpha
  */
-export interface CreateAirdropPreflightReport {
-    /** `true` when the creator has approved the factory as operator on `params.token`. */
-    isFactoryOperator: boolean;
-    /** Per-claim gas fee (wei) the factory will embed into the clone for this creator. */
-    gasFee: bigint;
-    /** Predicted CREATE2 clone address. `undefined` without `userSalt` or with invalid params. */
-    predictedAirdrop?: Address;
-    /** `true` when bytecode already exists at `predictedAirdrop`. `undefined` when not predicted. */
-    alreadyDeployed?: boolean;
-    /** `true` when no blockers were detected — green light to submit the write. */
-    ready: boolean;
-    /** Human-readable blocker descriptions. Empty when `ready === true`. */
-    blockers: string[];
-    /**
-     * Typed errors that would otherwise surface at write time, index-aligned
-     * with `blockers`. Empty when `ready === true`.
-     */
-    blockerErrors: TokenOpsSdkError[];
+export interface CreateAirdropArgs<P> {
+    params: P;
+    mode: DeploymentMode;
+    userSalt: Hex;
+}
+/** @alpha */
+export interface CreateAirdropResult {
+    hash: Hex;
+    airdrop: Address;
+    complianceManager: Address;
+}
+/**
+ * One recipient's committed allocation, keyed for `CampaignEntry.merkleProof` construction.
+ *
+ * @alpha
+ */
+export interface CampaignRecipient {
+    recipient: Address;
+    /** The recipient's CUMULATIVE total, not a per-drop tranche. A claim pays
+     *  `total - min(total, alreadyDelivered)`. */
+    cumulativeTotal: bigint;
+}
+/**
+ * One recipient's encrypted, proof-bearing claim input — everything `merkle.claim` needs.
+ *
+ * @alpha
+ */
+export interface CampaignEntry {
+    recipient: Address;
+    handle: Hex;
+    inputProof: Hex;
+    merkleProof: readonly Hex[];
+}
+/** @alpha */
+export interface BuiltCampaign {
+    root: Hex;
+    entries: readonly CampaignEntry[];
 }

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

@@ -18,6 +18,61 @@ export declare class NotRegisteredError extends TokenOpsSdkError {
         cause?: unknown;
     });
 }
+/**
+ * Wallet-mode disperse: the user's registered sub-wallet pair has not (fully)
+ * approved the singleton as an ERC-7984 operator on the token, so the
+ * singleton cannot move funds held by the sub-wallets. Surfaced by
+ * `preflightDisperse` in `wallet` / `wallet-token-fee` mode.
+ *
+ * Remediation: call `approveUserWalletsForToken(token)` on the singleton —
+ * the per-wallet approval states are in `context` (and mirrored on
+ * `PreflightReport.hasApprovedSubwallets`).
+ */
+export declare class SubwalletsNotApprovedError extends TokenOpsSdkError {
+    readonly name = "SubwalletsNotApprovedError";
+    readonly context: {
+        method: string;
+        contractAddress: Address;
+        user: Address;
+        token: Address;
+        wallet0Approved: boolean;
+        wallet1Approved: boolean;
+    };
+    constructor(args: {
+        method: string;
+        contractAddress: Address;
+        user: Address;
+        token: Address;
+        wallet0Approved: boolean;
+        wallet1Approved: boolean;
+        cause?: unknown;
+    });
+}
+/**
+ * Direct-mode disperse: the sender has not approved the singleton as an
+ * ERC-7984 operator on the token, so `disperseConfidentialTokenDirect` would
+ * revert with the raw `ERC7984UnauthorizedSpender` selector (`0x79f2cb38`).
+ * Surfaced by `preflightDisperse` in `direct` mode.
+ *
+ * Remediation: call `setOperator()` / `ensureOperator()` (exported from
+ * `@tokenops/sdk/fhe`) with the singleton address before dispersing.
+ */
+export declare class SingletonNotApprovedError extends TokenOpsSdkError {
+    readonly name = "SingletonNotApprovedError";
+    readonly context: {
+        method: string;
+        contractAddress: Address;
+        user: Address;
+        token: Address;
+    };
+    constructor(args: {
+        method: string;
+        contractAddress: Address;
+        user: Address;
+        token: Address;
+        cause?: unknown;
+    });
+}
 /**
  * The user has already registered — `register(token)` is single-use per user.
  * Use `approveUserWalletsForToken(token)` to grant the existing wallet pair

package/dist/fhe-disperse/index.cjs

@@ -1,98 +1,107 @@
 'use strict';
 
-var chunkPFXURMBZ_cjs = require('../chunk-PFXURMBZ.cjs');
-var chunkJYOTGRSO_cjs = require('../chunk-JYOTGRSO.cjs');
+var chunkJZLGCTGK_cjs = require('../chunk-JZLGCTGK.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-KLKI352M.cjs');
-require('../chunk-PUPKNW3R.cjs');
+require('../chunk-UG5RKLU2.cjs');
+require('../chunk-MVDQMV25.cjs');
+require('../chunk-5576FRT3.cjs');
 require('../chunk-JK4XMMKM.cjs');
-require('../chunk-VJKZWYYJ.cjs');
 require('../chunk-66IHPTOK.cjs');
 var chunk67OV5CX2_cjs = require('../chunk-67OV5CX2.cjs');
+require('../chunk-VJKZWYYJ.cjs');
 
 
 
 Object.defineProperty(exports, "AlreadyRegisteredError", {
   enumerable: true,
-  get: function () { return chunkPFXURMBZ_cjs.AlreadyRegisteredError; }
+  get: function () { return chunkJZLGCTGK_cjs.AlreadyRegisteredError; }
 });
 Object.defineProperty(exports, "ConfidentialDisperseClient", {
   enumerable: true,
-  get: function () { return chunkPFXURMBZ_cjs.ConfidentialDisperseClient; }
+  get: function () { return chunkJZLGCTGK_cjs.ConfidentialDisperseClient; }
 });
 Object.defineProperty(exports, "DEFAULT_ADMIN_ROLE", {
   enumerable: true,
-  get: function () { return chunkPFXURMBZ_cjs.DEFAULT_ADMIN_ROLE; }
+  get: function () { return chunkJZLGCTGK_cjs.DEFAULT_ADMIN_ROLE; }
 });
 Object.defineProperty(exports, "DisperseEncryptedReserveNotGrantedError", {
   enumerable: true,
-  get: function () { return chunkPFXURMBZ_cjs.DisperseEncryptedReserveNotGrantedError; }
+  get: function () { return chunkJZLGCTGK_cjs.DisperseEncryptedReserveNotGrantedError; }
 });
 Object.defineProperty(exports, "DisperseSubwalletNotFoundError", {
   enumerable: true,
-  get: function () { return chunkPFXURMBZ_cjs.DisperseSubwalletNotFoundError; }
+  get: function () { return chunkJZLGCTGK_cjs.DisperseSubwalletNotFoundError; }
 });
 Object.defineProperty(exports, "FEE_COLLECTOR_ROLE", {
   enumerable: true,
-  get: function () { return chunkPFXURMBZ_cjs.FEE_COLLECTOR_ROLE; }
+  get: function () { return chunkJZLGCTGK_cjs.FEE_COLLECTOR_ROLE; }
 });
 Object.defineProperty(exports, "FEE_MANAGER_ROLE", {
   enumerable: true,
-  get: function () { return chunkPFXURMBZ_cjs.FEE_MANAGER_ROLE; }
+  get: function () { return chunkJZLGCTGK_cjs.FEE_MANAGER_ROLE; }
 });
 Object.defineProperty(exports, "NotRegisteredError", {
   enumerable: true,
-  get: function () { return chunkPFXURMBZ_cjs.NotRegisteredError; }
+  get: function () { return chunkJZLGCTGK_cjs.NotRegisteredError; }
 });
 Object.defineProperty(exports, "PAUSER_ROLE", {
   enumerable: true,
-  get: function () { return chunkPFXURMBZ_cjs.PAUSER_ROLE; }
+  get: function () { return chunkJZLGCTGK_cjs.PAUSER_ROLE; }
+});
+Object.defineProperty(exports, "SingletonNotApprovedError", {
+  enumerable: true,
+  get: function () { return chunkJZLGCTGK_cjs.SingletonNotApprovedError; }
+});
+Object.defineProperty(exports, "SubwalletsNotApprovedError", {
+  enumerable: true,
+  get: function () { return chunkJZLGCTGK_cjs.SubwalletsNotApprovedError; }
 });
 Object.defineProperty(exports, "WITHDRAWER_ROLE", {
   enumerable: true,
-  get: function () { return chunkPFXURMBZ_cjs.WITHDRAWER_ROLE; }
+  get: function () { return chunkJZLGCTGK_cjs.WITHDRAWER_ROLE; }
 });
 Object.defineProperty(exports, "computeSubtotals", {
   enumerable: true,
-  get: function () { return chunkPFXURMBZ_cjs.computeSubtotals; }
+  get: function () { return chunkJZLGCTGK_cjs.computeSubtotals; }
 });
 Object.defineProperty(exports, "createConfidentialDisperseClient", {
   enumerable: true,
-  get: function () { return chunkPFXURMBZ_cjs.createConfidentialDisperseClient; }
+  get: function () { return chunkJZLGCTGK_cjs.createConfidentialDisperseClient; }
 });
 Object.defineProperty(exports, "disperseConfidentialAbi", {
   enumerable: true,
-  get: function () { return chunkPFXURMBZ_cjs.disperseConfidentialAbi; }
+  get: function () { return chunkJZLGCTGK_cjs.disperseConfidentialAbi; }
 });
 Object.defineProperty(exports, "disperseWalletAbi", {
   enumerable: true,
-  get: function () { return chunkPFXURMBZ_cjs.disperseWalletAbi; }
+  get: function () { return chunkJZLGCTGK_cjs.disperseWalletAbi; }
 });
 Object.defineProperty(exports, "encryptUint64", {
   enumerable: true,
-  get: function () { return chunkPFXURMBZ_cjs.encryptUint64; }
+  get: function () { return chunkJZLGCTGK_cjs.encryptUint64; }
 });
 Object.defineProperty(exports, "encryptUint64Batch", {
   enumerable: true,
-  get: function () { return chunkPFXURMBZ_cjs.encryptUint64Batch; }
+  get: function () { return chunkJZLGCTGK_cjs.encryptUint64Batch; }
 });
 Object.defineProperty(exports, "resolveEncryptor", {
   enumerable: true,
-  get: function () { return chunkPFXURMBZ_cjs.resolveEncryptor; }
+  get: function () { return chunkJZLGCTGK_cjs.resolveEncryptor; }
 });
 Object.defineProperty(exports, "ERC7984_OPERATOR_MAX_DEADLINE", {
   enumerable: true,
-  get: function () { return chunkJYOTGRSO_cjs.ERC7984_OPERATOR_MAX_DEADLINE; }
+  get: function () { return chunkKFRDLKMA_cjs.ERC7984_OPERATOR_MAX_DEADLINE; }
 });
 Object.defineProperty(exports, "revokeOperator", {
   enumerable: true,
-  get: function () { return chunkJYOTGRSO_cjs.revokeOperator; }
+  get: function () { return chunkKFRDLKMA_cjs.revokeOperator; }
 });
 Object.defineProperty(exports, "setOperator", {
   enumerable: true,
-  get: function () { return chunkJYOTGRSO_cjs.setOperator; }
+  get: function () { return chunkKFRDLKMA_cjs.setOperator; }
 });
 Object.defineProperty(exports, "erc7984OperatorAbi", {
   enumerable: true,

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

@@ -11,4 +11,4 @@ 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 { NotRegisteredError, AlreadyRegisteredError } from "./errors.js";
+export { NotRegisteredError, AlreadyRegisteredError, SubwalletsNotApprovedError, SingletonNotApprovedError, } from "./errors.js";

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

@@ -11,4 +11,4 @@ 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 { NotRegisteredError, AlreadyRegisteredError } from "./errors.js";
+export { NotRegisteredError, AlreadyRegisteredError, SubwalletsNotApprovedError, SingletonNotApprovedError, } from "./errors.js";

package/dist/fhe-disperse/index.js

@@ -1,11 +1,12 @@
-export { AlreadyRegisteredError, ConfidentialDisperseClient, DEFAULT_ADMIN_ROLE, DisperseEncryptedReserveNotGrantedError, DisperseSubwalletNotFoundError, FEE_COLLECTOR_ROLE, FEE_MANAGER_ROLE, NotRegisteredError, PAUSER_ROLE, WITHDRAWER_ROLE, computeSubtotals, createConfidentialDisperseClient, disperseConfidentialAbi, disperseWalletAbi, encryptUint64, encryptUint64Batch, resolveEncryptor } from '../chunk-2PWNH3UE.js';
-export { ERC7984_OPERATOR_MAX_DEADLINE, revokeOperator, setOperator } from '../chunk-6BMP4ICG.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-H5POPGOZ.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-SG65XWH7.js';
-import '../chunk-XGGTQQFH.js';
+import '../chunk-NWFMBLSQ.js';
+import '../chunk-4RAAATVY.js';
+import '../chunk-DZHYSUGY.js';
 import '../chunk-ZA673I3O.js';
-import '../chunk-Q2GP5UDC.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';
+import '../chunk-Q2GP5UDC.js';