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

package/dist/{chunk-X7WBPCEU.js → chunk-BXX5TETM.js}

@@ -1,8 +1,8 @@
-import { assertSupportedChain, airdropProductMapper, assertMerkleModeSupported, assertStockWrapper, assertSaltAvailable, assertMerkleClaimIdentity, DEDUP_MODE, DEPLOYMENT_MODE } from './chunk-VW356KR3.js';
+import { assertSupportedChain, airdropProductMapper, assertMerkleModeSupported, assertGasFeeAccepted, assertStockWrapper, assertSaltAvailable, assertMerkleClaimIdentity, DEDUP_MODE, DEPLOYMENT_MODE } from './chunk-LEYYG4RF.js';
 import { requireFhevmAclAddress, ACL_ALLOWED_EVENT } from './chunk-ZWXJTBZO.js';
 import { SDK_VERSION } from './chunk-NWFMBLSQ.js';
 import { isContractRevert, mapContractRevert } from './chunk-4RAAATVY.js';
-import { requireFheAirdropFactoryAddress } from './chunk-A4DCEE33.js';
+import { requireFheAirdropFactoryAddress } from './chunk-6HCT4QIX.js';
 import { normaliseAddress } from './chunk-ZA673I3O.js';
 import { asTxHash, asEncryptedHandle, asExternalInputProof, asSignature } from './chunk-KWFFIJYX.js';
 import { DeploymentAddressUnavailableError, InvalidArgumentError, MissingWalletClientError, MissingAccountError, TokenOpsSdkError, MissingEncryptorError, ReceiptEventNotFoundError } from './chunk-QBJ7O2B4.js';
@@ -69,6 +69,11 @@ var airdropFactoryAbi = [
         internalType: "uint96",
         name: "defaultGasFee_",
         type: "uint96"
+      },
+      {
+        internalType: "uint96",
+        name: "maxGasFee_",
+        type: "uint96"
       }
     ],
     stateMutability: "nonpayable",
@@ -173,6 +178,38 @@ var airdropFactoryAbi = [
     name: "FailedDeployment",
     type: "error"
   },
+  {
+    inputs: [
+      {
+        internalType: "uint96",
+        name: "gasFee",
+        type: "uint96"
+      },
+      {
+        internalType: "uint96",
+        name: "maxGasFee",
+        type: "uint96"
+      }
+    ],
+    name: "GasFeeExceedsMaximum",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint96",
+        name: "resolvedFee",
+        type: "uint96"
+      },
+      {
+        internalType: "uint96",
+        name: "maxAcceptedGasFee",
+        type: "uint96"
+      }
+    ],
+    name: "GasFeeNotAccepted",
+    type: "error"
+  },
   {
     inputs: [
       {
@@ -391,6 +428,11 @@ var airdropFactoryAbi = [
     name: "ZeroToken",
     type: "error"
   },
+  {
+    inputs: [],
+    name: "ZeroUnwrapRequestId",
+    type: "error"
+  },
   {
     anonymous: false,
     inputs: [
@@ -423,6 +465,12 @@ var airdropFactoryAbi = [
         internalType: "uint256",
         name: "deploymentBlockNumber",
         type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "gasFee",
+        type: "uint256"
       }
     ],
     name: "AirdropInitialized",
@@ -927,6 +975,19 @@ var airdropFactoryAbi = [
     name: "SetDefaultGasFee",
     type: "event"
   },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "maxGasFee",
+        type: "uint256"
+      }
+    ],
+    name: "SetMaxGasFee",
+    type: "event"
+  },
   {
     anonymous: false,
     inputs: [
@@ -1218,6 +1279,11 @@ var airdropFactoryAbi = [
                 internalType: "address",
                 name: "complianceAdmin",
                 type: "address"
+              },
+              {
+                internalType: "uint96",
+                name: "maxAcceptedGasFee",
+                type: "uint96"
               }
             ],
             internalType: "struct IAirdropFactory.CommonAirdropParams",
@@ -1306,6 +1372,11 @@ var airdropFactoryAbi = [
                 internalType: "address",
                 name: "complianceAdmin",
                 type: "address"
+              },
+              {
+                internalType: "uint96",
+                name: "maxAcceptedGasFee",
+                type: "uint96"
               }
             ],
             internalType: "struct IAirdropFactory.CommonAirdropParams",
@@ -1394,6 +1465,11 @@ var airdropFactoryAbi = [
                 internalType: "address",
                 name: "complianceAdmin",
                 type: "address"
+              },
+              {
+                internalType: "uint96",
+                name: "maxAcceptedGasFee",
+                type: "uint96"
               }
             ],
             internalType: "struct IAirdropFactory.CommonAirdropParams",
@@ -1472,6 +1548,11 @@ var airdropFactoryAbi = [
                 internalType: "address",
                 name: "complianceAdmin",
                 type: "address"
+              },
+              {
+                internalType: "uint96",
+                name: "maxAcceptedGasFee",
+                type: "uint96"
               }
             ],
             internalType: "struct IAirdropFactory.CommonAirdropParams",
@@ -1738,6 +1819,11 @@ var airdropFactoryAbi = [
                 internalType: "address",
                 name: "complianceAdmin",
                 type: "address"
+              },
+              {
+                internalType: "uint96",
+                name: "maxAcceptedGasFee",
+                type: "uint96"
               }
             ],
             internalType: "struct IAirdropFactory.CommonAirdropParams",
@@ -1811,6 +1897,11 @@ var airdropFactoryAbi = [
                 internalType: "address",
                 name: "complianceAdmin",
                 type: "address"
+              },
+              {
+                internalType: "uint96",
+                name: "maxAcceptedGasFee",
+                type: "uint96"
               }
             ],
             internalType: "struct IAirdropFactory.CommonAirdropParams",
@@ -2003,6 +2094,38 @@ var airdropFactoryAbi = [
     stateMutability: "view",
     type: "function"
   },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "candidate",
+        type: "address"
+      }
+    ],
+    name: "isAirdrop",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "maxGasFee",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
   {
     inputs: [],
     name: "merkleImplementation",
@@ -2051,6 +2174,11 @@ var airdropFactoryAbi = [
                 internalType: "address",
                 name: "complianceAdmin",
                 type: "address"
+              },
+              {
+                internalType: "uint96",
+                name: "maxAcceptedGasFee",
+                type: "uint96"
               }
             ],
             internalType: "struct IAirdropFactory.CommonAirdropParams",
@@ -2134,6 +2262,11 @@ var airdropFactoryAbi = [
                 internalType: "address",
                 name: "complianceAdmin",
                 type: "address"
+              },
+              {
+                internalType: "uint96",
+                name: "maxAcceptedGasFee",
+                type: "uint96"
               }
             ],
             internalType: "struct IAirdropFactory.CommonAirdropParams",
@@ -2345,6 +2478,19 @@ var airdropFactoryAbi = [
     stateMutability: "nonpayable",
     type: "function"
   },
+  {
+    inputs: [
+      {
+        internalType: "uint96",
+        name: "maxGasFee_",
+        type: "uint96"
+      }
+    ],
+    name: "setMaxGasFee",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
   {
     inputs: [
       {
@@ -2763,6 +2909,11 @@ var ecdsaConfidentialAirdropAbi = [
     name: "ZeroToken",
     type: "error"
   },
+  {
+    inputs: [],
+    name: "ZeroUnwrapRequestId",
+    type: "error"
+  },
   {
     anonymous: false,
     inputs: [
@@ -2795,6 +2946,12 @@ var ecdsaConfidentialAirdropAbi = [
         internalType: "uint256",
         name: "deploymentBlockNumber",
         type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "gasFee",
+        type: "uint256"
       }
     ],
     name: "AirdropInitialized",
@@ -3907,6 +4064,19 @@ var ecdsaConfidentialAirdropAbi = [
     stateMutability: "view",
     type: "function"
   },
+  {
+    inputs: [],
+    name: "refreshComplianceBalance",
+    outputs: [
+      {
+        internalType: "euint64",
+        name: "balance",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
   {
     inputs: [
       {
@@ -4294,6 +4464,11 @@ var confidentialAirdropBaseAbi = [
     name: "ZeroToken",
     type: "error"
   },
+  {
+    inputs: [],
+    name: "ZeroUnwrapRequestId",
+    type: "error"
+  },
   {
     anonymous: false,
     inputs: [
@@ -4326,6 +4501,12 @@ var confidentialAirdropBaseAbi = [
         internalType: "uint256",
         name: "deploymentBlockNumber",
         type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "gasFee",
+        type: "uint256"
       }
     ],
     name: "AirdropInitialized",
@@ -4802,6 +4983,19 @@ var confidentialAirdropBaseAbi = [
     stateMutability: "nonpayable",
     type: "function"
   },
+  {
+    inputs: [],
+    name: "refreshComplianceBalance",
+    outputs: [
+      {
+        internalType: "euint64",
+        name: "balance",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
   {
     inputs: [
       {
@@ -5201,8 +5395,12 @@ var AirdropBaseClient = class {
    * Sweep a plain ERC-20 that was sent to the instance by mistake. Requires
    * `RESCUER_ROLE`.
    *
-   * The campaign's own token is ERC-7984, not ERC-20, so it cannot be reached
-   * through this path — use {@link withdrawConfidential} for the pool.
+   * Passing the campaign's own token reverts `CannotRescueAirdropToken`
+   * (audit-05), matching {@link rescueOtherConfidentialToken}. ERC-7984 and
+   * ERC-20 are not disjoint in practice - a wrapper token answers both
+   * interfaces - so "the pool token is confidential, therefore out of reach
+   * here" was never a guarantee, only an assumption. Use
+   * {@link withdrawConfidential} for the pool.
    *
    * @returns The transaction hash.
    */
@@ -5562,17 +5760,56 @@ var AirdropBaseClient = class {
   //                    DISCLOSURE (ENCRYPTED)
   // ============================================================
   //
-  // The first three read like getters and are `nonpayable` in the ABI: they
+  // The first four read like getters and are `nonpayable` in the ABI: they
   // call `FHE.allow`, which writes ACL state. They therefore submit a
   // transaction and recover their `euint64` result from the receipt — never
   // from a simulation. See `extractGrantedHandle`.
   //
+  // Three of those four grant the CALLER; `refreshComplianceBalance` grants the
+  // compliance clone instead, which is why it resolves the clone address and
+  // passes it as `grantee`.
+  //
   // The last two return nothing on-chain and are ordinary writes: they grant a
   // handle the caller already has, so there is no new handle to recover.
+  /**
+   * Re-grant the compliance-manager clone on the instance's current pool
+   * balance, and return the handle it was granted on.
+   *
+   * **Permissionless, and deliberately so** (audit-04). The token rotates the
+   * instance's balance handle on every incoming transfer, including one no
+   * airdrop code observes - a third party transferring in directly - and
+   * grants the fresh handle to the token and the holder only. Without this the
+   * compliance clone's grant can be stranded on a handle the token has already
+   * replaced, with no admin necessarily around to restore it. There is no
+   * argument to abuse: the only handle read is `address(this)`'s own balance,
+   * and the only grantee is the clone wired at initialization.
+   *
+   * This is therefore the normative way to obtain a readable live-balance
+   * handle - and it is a **snapshot, not a subscription**. Grants are
+   * append-only, so the handle this returns stays readable forever; but the
+   * next incoming transfer rotates the instance to a NEW handle the clone was
+   * never granted on. A compliance reader that refreshes once and stops is
+   * reading a stale balance, not a live one. Call it again after any transfer
+   * in, or before each read.
+   *
+   * @returns `{ handle, hash }` - the handle the compliance clone may now decrypt.
+   * @throws {@link ReceiptEventNotFoundError} when the transaction granted no ACL to the clone.
+   */
+  async refreshComplianceBalance(args = {}) {
+    const grantee = await this.complianceManager();
+    return this.encryptedView({
+      functionName: "refreshComplianceBalance",
+      grantee,
+      account: args.account
+    });
+  }
   /**
    * Read the instance's own remaining pool balance as a handle the **caller**
    * can decrypt. Requires `DISCLOSURE_ADMIN_ROLE`.
    *
+   * Also re-grants the compliance-manager clone on the same handle (audit-04),
+   * so an admin read doubles as a {@link refreshComplianceBalance}.
+   *
    * @returns `{ handle, hash }` — pass `handle` to the Zama relayer's `userDecrypt`.
    * @throws {@link ReceiptEventNotFoundError} when the transaction granted no ACL to the caller.
    */
@@ -5648,11 +5885,18 @@ var AirdropBaseClient = class {
   /**
    * Grant `party` decrypt access to a handle you already hold.
    *
-   * Two gates apply on-chain: the caller must itself be allowed on the handle
-   * (bypassed by `DISCLOSURE_ADMIN_ROLE`), and the *instance* must be allowed
-   * on it — so an arbitrary handle from another contract cannot be laundered
-   * through this campaign. A failure of the first surfaces as
-   * `FheHandleNotAllowedError`.
+   * Two gates apply on-chain. Gate #1: the handle must be **persistently**
+   * user-decryptable in the `(caller, instance)` context - BOTH legs, and a
+   * transient allowance does not satisfy either (audit-06). `DISCLOSURE_ADMIN_ROLE`
+   * bypasses gate #1 only. Gate #2: the instance must be allowed on the handle,
+   * so an arbitrary handle from another contract cannot be laundered through
+   * this campaign.
+   *
+   * **The transient case is the trap.** An `euint64` that just came back from
+   * an FHE op carries a transient allowance, which used to be enough here and
+   * no longer is. Handles worth disclosing come from the encrypted views on
+   * this client, whose grants are persistent. A gate #1 failure surfaces as
+   * `FheHandleNotAllowedError` carrying the offending handle.
    *
    * @param args.handle An existing `euint64` handle — a public pointer, not a value.
    * @returns The transaction hash. No new handle is produced.
@@ -5922,11 +6166,24 @@ var EcdsaAirdropClient = class extends AirdropBaseClient {
    * consuming either replay guard — the same input can still be claimed for
    * real afterwards. No fee.
    *
+   * **It is repeatable, not unconditional** (audit-07). While the claim is
+   * still available this may be called any number of times; once it is not,
+   * this reverts with the same error the consuming claim would raise, in the
+   * same order: the mode's dedup slot first (`AddressAlreadyClaimed` /
+   * `DedupIdAlreadyClaimed`), the EIP-712 digest second (`SignatureAlreadyUsed`).
+   * A rejected preview performs no FHE op, grants no ACL and emits nothing.
+   *
+   * So this is not a probe for "has this been claimed" - use
+   * {@link isSignatureValid}, which never reverts and answers the same
+   * question for free. Reach for this when you want the AMOUNT.
+   *
    * An encrypted view: the contract calls `FHE.allow(amount, msg.sender)`, so
    * the result is recovered from the receipt's ACL `Allowed` event, never
    * from a simulation. See {@link AirdropBaseClient}'s class TSDoc.
    *
    * @returns `{ handle, hash }` — pass `handle` to the Zama relayer's `userDecrypt`.
+   * @throws {@link AlreadyClaimedError} when this recipient's dedup slot is consumed.
+   * @throws {@link DedupIdConsumedError} when this `dedupId`'s slot is consumed.
    */
   async getClaimAmount(args) {
     return this.encryptedView({
@@ -6126,7 +6383,8 @@ function toContractCommonParams(common) {
     endTime: common.endTime,
     canExtendClaimWindow: common.canExtendClaimWindow,
     unwrappable: common.unwrappable,
-    complianceAdmin: common.complianceAdmin
+    complianceAdmin: common.complianceAdmin,
+    maxAcceptedGasFee: common.maxAcceptedGasFee
   };
 }
 function toContractEcdsaParams(params) {
@@ -6483,11 +6741,28 @@ var ConfidentialAirdropFactoryClient = class {
   async airdrops(offset, limit) {
     return this.#read("airdrops", [offset, limit]);
   }
+  /**
+   * Whether THIS factory created `candidate` - the genuineness check (audit-10).
+   *
+   * Nothing observable at an instance proves which factory, if any, deployed
+   * it: an attacker can deploy a contract with the same ABI, the same events
+   * and a pool it controls. The only trustworthy question is whether the
+   * canonical factory's own registry contains the address, which is why this
+   * read has to be addressed to a factory taken from
+   * `src/core/addresses.ts` rather than one the instance names.
+   *
+   * @param candidate The address to check.
+   * @returns True when this factory's registry contains `candidate`.
+   */
+  async isAirdrop(candidate) {
+    return this.#read("isAirdrop", [candidate]);
+  }
   /**
    * The compliance-manager clone bound to an instance.
    *
-   * Doubles as a provenance check: the factory records this mapping only for
-   * instances it deployed, so a zero address means the instance is not ours.
+   * Doubles as a provenance check, though a weaker one than {@link isAirdrop}:
+   * the factory records this mapping only for instances it deployed, so a zero
+   * address means the instance is not ours.
    *
    * @param airdrop Instance address.
    * @returns The clone address, or the zero address when unknown to this factory.
@@ -6541,6 +6816,47 @@ var ConfidentialAirdropFactoryClient = class {
   async defaultGasFee() {
     return this.#read("defaultGasFee");
   }
+  /** The factory's own ceiling on every configurable fee and every create-time resolved fee. */
+  async maxGasFee() {
+    return this.#read("maxGasFee");
+  }
+  /**
+   * Set the factory's ceiling on every fee `setDefaultGasFee`/`setCustomFee`
+   * may configure, and on the fee resolved at create.
+   *
+   * Requires `DEFAULT_ADMIN_ROLE`, deliberately not `FEE_MANAGER_ROLE`: the fee
+   * manager moves fees only within a bound the admin controls. `0n` admits a
+   * zero fee and nothing else.
+   *
+   * Lowering it below an already-configured fee does not rewrite that fee - the
+   * stale value stays in storage and reverts `GasFeeExceedsMaximum` at the next
+   * create until it is lowered too.
+   *
+   * @throws {@link InvalidArgumentError} when `maxGasFee` is below a currently configured fee (`GasFeeExceedsMaximum`).
+   */
+  async setMaxGasFee(maxGasFee, account) {
+    return this.#write("setMaxGasFee", [maxGasFee], account, "setMaxGasFee");
+  }
+  /**
+   * The per-claim fee a `create*` from `creator` would freeze into the new
+   * instance right now: their {@link getCustomFee} override when enabled, else
+   * {@link defaultGasFee}.
+   *
+   * This is the number `CommonAirdropParams.maxAcceptedGasFee` is checked
+   * against, so it is also what to show a creator before they choose a bound.
+   * It is a snapshot, not a quote: `FEE_MANAGER_ROLE` can move it between this
+   * read and the create, which is exactly what the bound exists to catch.
+   *
+   * @param creator The account that will send `create*`.
+   * @returns The resolved fee in wei.
+   */
+  async resolveGasFee(creator) {
+    const [custom, fallback] = await Promise.all([
+      this.getCustomFee(creator),
+      this.defaultGasFee()
+    ]);
+    return custom.enabled ? custom.gasFee : fallback;
+  }
   // ----------------------- implementation admin -----------------------
   /**
    * Point future `createEcdsaAirdrop*` calls at a new ECDSA implementation.
@@ -6805,17 +7121,15 @@ var ConfidentialAirdropFactoryClient = class {
   /**
    * Revoke `role` from `holder`. Requires the role's admin role.
    *
-   * Unlike an airdrop instance, the factory declares no "never empty" floor:
-   * revoking the last `DEFAULT_ADMIN_ROLE` member succeeds, and what it
-   * freezes is **role administration**, permanently. `DEFAULT_ADMIN_ROLE`
-   * administers all four operational roles and itself, so with the set empty
-   * no role can ever be granted or revoked again - including putting an admin
-   * back. The four operational roles keep working for whoever already holds
-   * them: a `FEE_MANAGER_ROLE` holder can still call {@link setDefaultGasFee},
-   * an `IMPL_MANAGER_ROLE` holder can still rotate an implementation. The
-   * factory therefore keeps running with exactly the role holders it had at
-   * that moment, with no way to rotate or remove them. Grant the successor
-   * first.
+   * **The factory floors `DEFAULT_ADMIN_ROLE` at one live member** (audit-14),
+   * matching the instances. Renouncing or revoking the sole holder reverts
+   * `LastAdmin`, and granting the role to the zero address reverts
+   * `ZeroAdminGrant`, so the set can neither be emptied nor satisfied by a
+   * member nobody controls. Before audit-14 this succeeded and froze role
+   * administration permanently; it no longer does.
+   *
+   * A handover is still available and is the supported way out: grant the
+   * successor first, then renounce.
    *
    * @returns The transaction hash.
    */
@@ -6887,11 +7201,15 @@ var ConfidentialAirdropFactoryClient = class {
   /**
    * The create-time guardrails that need a read, run before anything is sent.
    *
-   * Two checks, in the order a failure is cheapest to discover:
+   * Three checks, in the order a failure is cheapest to discover:
    *
-   * 1. **Stock wrapper.** Only when `unwrappable` is requested; one
+   * 1. **Accepted gas fee.** The fee is frozen into the instance at
+   *    initialization and immutable after, so a bound that no longer holds must
+   *    stop the transaction before anything else is spent on it (see
+   *    {@link GasFeeNotAcceptedError}).
+   * 2. **Stock wrapper.** Only when `unwrappable` is requested; one
    *    `underlying()` probe (see {@link NonStockWrapperError}).
-   * 2. **Salt collision.** A predicted address commits to `(implementation,
+   * 3. **Salt collision.** A predicted address commits to `(implementation,
    *    mode, deployer, userSalt)` and ignores the params struct entirely, so
    *    two campaigns differing only in token, window, signer or root still
    *    land on one address. The prediction plus one `eth_getCode` turns that
@@ -6902,6 +7220,12 @@ var ConfidentialAirdropFactoryClient = class {
    */
   async #guardCreate(input) {
     const { variant, args, deployer, method } = input;
+    await assertGasFeeAccepted({
+      factory: this,
+      creator: deployer,
+      maxAcceptedGasFee: args.params.common.maxAcceptedGasFee,
+      method
+    });
     await assertStockWrapper({
       publicClient: this.publicClient,
       token: args.params.common.token,
@@ -7433,6 +7757,11 @@ var merkleConfidentialAirdropAbi = [
     name: "ZeroToken",
     type: "error"
   },
+  {
+    inputs: [],
+    name: "ZeroUnwrapRequestId",
+    type: "error"
+  },
   {
     anonymous: false,
     inputs: [
@@ -7465,6 +7794,12 @@ var merkleConfidentialAirdropAbi = [
         internalType: "uint256",
         name: "deploymentBlockNumber",
         type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "gasFee",
+        type: "uint256"
       }
     ],
     name: "AirdropInitialized",
@@ -8492,6 +8827,19 @@ var merkleConfidentialAirdropAbi = [
     stateMutability: "view",
     type: "function"
   },
+  {
+    inputs: [],
+    name: "refreshComplianceBalance",
+    outputs: [
+      {
+        internalType: "euint64",
+        name: "balance",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
   {
     inputs: [
       {

package/dist/{chunk-GADGBQJO.js → chunk-GCJFAY4X.js}

@@ -1,5 +1,5 @@
-import { resolveEncryptor, encryptUint64Batch, encryptUint64 } from './chunk-X7WBPCEU.js';
-import { assertPredictionFresh, FeeCollectorSelfAdministeredError } from './chunk-VW356KR3.js';
+import { resolveEncryptor, encryptUint64Batch, encryptUint64 } from './chunk-BXX5TETM.js';
+import { assertPredictionFresh, FeeCollectorSelfAdministeredError } from './chunk-LEYYG4RF.js';
 import { normaliseAddress } from './chunk-ZA673I3O.js';
 import { InvalidArgumentError, MissingWalletClientError, MissingAccountError, ContractRevertError, MissingEncryptorError, isTokenOpsSdkError, UnknownWriteFailureError } from './chunk-QBJ7O2B4.js';
 import { StandardMerkleTree } from '@openzeppelin/merkle-tree';