@tokenops/sdk 1.6.0 → 2.0.0-alpha.2

package/dist/fhe-airdrop/advanced/react/useSetCustomFee.d.ts

@@ -0,0 +1,28 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import type { WriteAccountOverride } from "../../airdrop-base.js";
+import { type AirdropClientOptions } from "../../react/_shared.js";
+/** @alpha */
+export interface SetCustomFeeArgs extends WriteAccountOverride {
+    /** The creator whose fee is being overridden - NOT the admin sending the transaction. */
+    creator: Address;
+    /** Wei charged per claim for this creator's future instances, `uint96` on-chain. */
+    gasFee: bigint;
+}
+/**
+ * Override the factory's default per-claim gas fee for one creator.
+ *
+ * Requires `FEE_MANAGER_ROLE`.
+ *
+ * **Invalidates:** `useFactoryCustomFee({ creator })` for the TARGET creator -
+ * `variables.creator`, never the sending admin. `account` is the submitter and
+ * has no cache entry of its own here, so keying the invalidation off it would
+ * refresh the wrong row and leave the edited one stale.
+ *
+ * @example
+ * const setCustomFee = useSetCustomFee();
+ * await setCustomFee.mutateAsync({ creator, gasFee: 0n });
+ *
+ * @alpha
+ */
+export declare function useSetCustomFee(options?: AirdropClientOptions): UseMutationResult<Hex, Error, SetCustomFeeArgs>;

package/dist/fhe-airdrop/advanced/react/useSetDefaultDelegateToCompliance.d.ts

@@ -0,0 +1,31 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Hex } from "viem";
+import type { WriteAccountOverride } from "../../airdrop-base.js";
+import { type AirdropClientOptions } from "../../react/_shared.js";
+/** @alpha */
+export interface SetDefaultDelegateToComplianceArgs extends WriteAccountOverride {
+    /** Whether new instances default to delegating compliance disclosure to the platform delegate. */
+    on: boolean;
+}
+/**
+ * Set the factory-wide default for whether new instances delegate compliance
+ * disclosure to the platform delegate. Requires `COMPLIANCE_WIRING_ROLE`.
+ *
+ * **Ordering is load-bearing.** `on: true` reverts `ZeroComplianceDelegate`
+ * unless {@link useSetComplianceDelegate} has already set a delegate - read
+ * {@link useFactoryComplianceDelegate} first and sequence the two writes.
+ *
+ * **Invalidates:** the `fn "effectiveDelegateToCompliance"` PREFIX and the
+ * `fn "compliancePolicy"` PREFIX - every cached creator at once, because this
+ * write is chain-wide: any creator without an override moves with the
+ * default, and {@link useFactoryCompliancePolicy}'s bundle carries the
+ * resolved `effective` field. Contrast {@link useSetCompliancePolicy}, which
+ * stays keyed on the one creator it targets.
+ *
+ * @example
+ * const setDefault = useSetDefaultDelegateToCompliance();
+ * await setDefault.mutateAsync({ on: true });
+ *
+ * @alpha
+ */
+export declare function useSetDefaultDelegateToCompliance(options?: AirdropClientOptions): UseMutationResult<Hex, Error, SetDefaultDelegateToComplianceArgs>;

package/dist/fhe-airdrop/advanced/react/useSetDefaultGasFee.d.ts

@@ -0,0 +1,28 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Hex } from "viem";
+import type { WriteAccountOverride } from "../../airdrop-base.js";
+import { type AirdropClientOptions } from "../../react/_shared.js";
+/** @alpha */
+export interface SetDefaultGasFeeArgs extends WriteAccountOverride {
+    /** Wei charged per claim, `uint96` on-chain. */
+    gasFee: bigint;
+}
+/**
+ * Set the per-claim gas fee that new instances default to when their creator
+ * has no `setCustomFee` override.
+ *
+ * Requires `FEE_MANAGER_ROLE`. Affects only instances created afterwards: an
+ * instance's `gasFee()` is baked in at create time, so no deployed campaign's
+ * fee changes.
+ *
+ * **Invalidates:** this factory's `useFactoryFees` entry (fn `"fees"`) only.
+ * Deliberately NOT any instance's fn `"gasFee"` key - those are immutable
+ * per instance and invalidating them would refetch unchanged values.
+ *
+ * @example
+ * const setDefaultFee = useSetDefaultGasFee();
+ * await setDefaultFee.mutateAsync({ gasFee: parseEther("0.0001") });
+ *
+ * @alpha
+ */
+export declare function useSetDefaultGasFee(options?: AirdropClientOptions): UseMutationResult<Hex, Error, SetDefaultGasFeeArgs>;

package/dist/fhe-airdrop/advanced/react/useSetDefaultUpgradeable.d.ts

@@ -0,0 +1,27 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Hex } from "viem";
+import type { WriteAccountOverride } from "../../airdrop-base.js";
+import { type AirdropClientOptions } from "../../react/_shared.js";
+/** @alpha */
+export interface SetDefaultUpgradeableArgs extends WriteAccountOverride {
+    /** Whether creators without an override may deploy `mode: "uups"`. */
+    allowed: boolean;
+}
+/**
+ * Set the factory-wide default for whether a `create*` may deploy
+ * `mode: "uups"`. Requires `UPGRADE_MANAGER_ROLE`.
+ *
+ * **Invalidates:** the `fn "effectiveUpgradeable"`,
+ * `fn "upgradeabilityPolicy"` and `fn `preflightCreate`` PREFIXES.
+ * Prefix invalidation is correct here because the write is chain-wide: every
+ * cached creator without an override moves with the default, and a preflight
+ * result is exactly the thing that flips between allowed and
+ * `UpgradeabilityNotAllowedError`.
+ *
+ * @example
+ * const setDefault = useSetDefaultUpgradeable();
+ * await setDefault.mutateAsync({ allowed: false });
+ *
+ * @alpha
+ */
+export declare function useSetDefaultUpgradeable(options?: AirdropClientOptions): UseMutationResult<Hex, Error, SetDefaultUpgradeableArgs>;

package/dist/fhe-airdrop/advanced/react/useSetEcdsaImplementation.d.ts

@@ -0,0 +1,34 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import type { WriteAccountOverride } from "../../airdrop-base.js";
+import { type AirdropClientOptions } from "../../react/_shared.js";
+/** @alpha */
+export interface SetEcdsaImplementationArgs extends WriteAccountOverride {
+    /** The new ECDSA implementation. The zero address reverts. */
+    implementation: Address;
+}
+/**
+ * Point future `createEcdsaAirdrop*` calls at a new ECDSA implementation.
+ *
+ * Requires `IMPL_MANAGER_ROLE`. Deployed instances are untouched - a clone
+ * stays bound to the implementation live when it was created.
+ *
+ * **Moving this pointer moves every future predicted address.** Any campaign
+ * plan built before this write is stale, and on an immutable-root instance
+ * its entries would be unclaimable; that is what `PredictionDriftError`
+ * exists to catch.
+ *
+ * **Invalidates:** `useFactoryImplementations` (fn `"implementations"`), plus
+ * the fn `"getEcdsaInitCodeHash"`, `"predictEcdsaAirdropAddress"` and
+ * ``preflightCreate`` PREFIXES - every cached args combination of each,
+ * because the init-code hash, the predicted address and the create preflight
+ * all shift together with the pointer. Invalidating the predictions is what
+ * stops a mounted UI offering a dead address.
+ *
+ * @example
+ * const setEcdsaImpl = useSetEcdsaImplementation();
+ * await setEcdsaImpl.mutateAsync({ implementation: newEcdsaImpl });
+ *
+ * @alpha
+ */
+export declare function useSetEcdsaImplementation(options?: AirdropClientOptions): UseMutationResult<Hex, Error, SetEcdsaImplementationArgs>;

package/dist/fhe-airdrop/advanced/react/useSetFeeCollector.d.ts

@@ -0,0 +1,27 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import type { WriteAccountOverride } from "../../airdrop-base.js";
+import { type AirdropClientOptions } from "../../react/_shared.js";
+/** @alpha */
+export interface SetFeeCollectorArgs extends WriteAccountOverride {
+    /** Where accrued claim-fee ETH withdraws to. The zero address reverts. */
+    feeCollector: Address;
+}
+/**
+ * Redirect where the factory's accrued claim-fee ETH withdraws to.
+ *
+ * Requires `FEE_MANAGER_ROLE`. The headless factory method takes positional
+ * args, so this hook adapts its object-shaped variables to
+ * `setFeeCollector(feeCollector, account?)`.
+ *
+ * **Invalidates:** this factory's `useFactoryFees` entry (fn `"fees"`), which
+ * bundles `feeCollector` with `defaultGasFee`. Nothing else moves - deployed
+ * instances hold no copy of the collector.
+ *
+ * @example
+ * const setCollector = useSetFeeCollector();
+ * await setCollector.mutateAsync({ feeCollector: treasuryAddress });
+ *
+ * @alpha
+ */
+export declare function useSetFeeCollector(options?: AirdropClientOptions): UseMutationResult<Hex, Error, SetFeeCollectorArgs>;

package/dist/fhe-airdrop/advanced/react/useSetMerkleImplementation.d.ts

@@ -0,0 +1,30 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import type { WriteAccountOverride } from "../../airdrop-base.js";
+import { type AirdropClientOptions } from "../../react/_shared.js";
+/** @alpha */
+export interface SetMerkleImplementationArgs extends WriteAccountOverride {
+    /** The new Merkle implementation. The zero address reverts. */
+    implementation: Address;
+}
+/**
+ * Point future `createMerkleAirdrop*` calls at a new Merkle implementation.
+ *
+ * Requires `IMPL_MANAGER_ROLE`. Deployed instances are untouched.
+ *
+ * **Same prediction-drift hazard as {@link useSetEcdsaImplementation}, with a
+ * worse blast radius.** Merkle campaigns are commonly immutable-root: a plan
+ * whose entries were bound to an address predicted before this write has no
+ * on-chain repair, so re-plan rather than re-point.
+ *
+ * **Invalidates:** `useFactoryImplementations` (fn `"implementations"`), plus
+ * the fn `"getMerkleInitCodeHash"`, `"predictMerkleAirdropAddress"` and
+ * ``preflightCreate`` PREFIXES - every cached args combination of each.
+ *
+ * @example
+ * const setMerkleImpl = useSetMerkleImplementation();
+ * await setMerkleImpl.mutateAsync({ implementation: newMerkleImpl });
+ *
+ * @alpha
+ */
+export declare function useSetMerkleImplementation(options?: AirdropClientOptions): UseMutationResult<Hex, Error, SetMerkleImplementationArgs>;

package/dist/fhe-airdrop/advanced/react/useSetUpgradeabilityPolicy.d.ts

@@ -0,0 +1,31 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import type { WriteAccountOverride } from "../../airdrop-base.js";
+import { type AirdropClientOptions } from "../../react/_shared.js";
+/** @alpha */
+export interface SetUpgradeabilityPolicyArgs extends WriteAccountOverride {
+    /** The creator the override applies to - not the admin sending the transaction. */
+    creator: Address;
+    /** Whether that creator may deploy `mode: "uups"`. */
+    allowed: boolean;
+}
+/**
+ * Override the factory's default upgradeability policy for one creator.
+ * Requires `UPGRADE_MANAGER_ROLE`.
+ *
+ * This is the write that flips whether that creator's next `mode: "uups"`
+ * create is refused with `UpgradeabilityNotAllowedError`.
+ *
+ * **Invalidates:** `fn "effectiveUpgradeable"` and
+ * `fn "upgradeabilityPolicy"` keyed on `args.creator` - the TARGET creator,
+ * never the sending admin - plus the `fn `preflightCreate`` PREFIX,
+ * which is keyed on the whole create payload rather than the creator alone
+ * and so cannot be narrowed here.
+ *
+ * @example
+ * const setPolicy = useSetUpgradeabilityPolicy();
+ * await setPolicy.mutateAsync({ creator, allowed: true });
+ *
+ * @alpha
+ */
+export declare function useSetUpgradeabilityPolicy(options?: AirdropClientOptions): UseMutationResult<Hex, Error, SetUpgradeabilityPolicyArgs>;