clanker-sdk 4.2.5 → 4.2.6

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { C as ClankerTokenV3 } from './clankerTokenV3-BqHTF9QY.js';
 import { a as Chain, C as ClankerTokenV4, b as ClankerDeployment } from './clankerTokenV4-xiAq6G4R.js';
 export { d as CLANKERS, g as Chains, h as ClankerDeployments, f as Clankers, R as RelatedV3_1, c as RelatedV4, T as Type, i as clankerConfigFor } from './clankerTokenV4-xiAq6G4R.js';
-import { ContractConstructorArgs, Hex } from 'viem';
+import { ContractConstructorArgs, Hex, PublicClient } from 'viem';
 import { C as ClankerToken_v3_1_abi, a as ClankerToken_v4_abi } from './ClankerToken-Dra5lppJ.js';
 import { StandardMerkleTree } from '@openzeppelin/merkle-tree';
 import 'zod/v4';
@@ -95,4 +95,135 @@ declare function createMerkleTree(entries: AirdropEntry[]): {
 declare function getMerkleProof(tree: StandardMerkleTree<[string, string]>, entries: [string, string][], account: `0x${string}`, amount: number): `0x${string}`[];
 declare function encodeAirdropData(merkleRoot: `0x${string}`, lockupDuration: number, vestingDuration: number): `0x${string}`;
 
-export { A0X_ADDRESS, ANON_ADDRESS, type AirdropEntry, CB_BTC_ADDRESS, CLANKER_ADDRESS, Chain, ClankerDeployment, ClankerTokenV4, DEFAULT_SUPPLY, DEGEN_ADDRESS, FEE_CONFIGS, FeeConfigs, HIGHER_ADDRESS, NATIVE_ADDRESS, POOL_POSITIONS, PoolPositions, WETH_ADDRESSES, createMerkleTree, encodeAirdropData, findVanityAddress, findVanityAddressV4, getMerkleProof, getTickFromMarketCap, getTickFromMarketCapUSDC, predictTokenAddressV4 };
+/**
+ * Represents an allowlist entry with an address and allowed ETH amount
+ */
+interface AllowlistEntry {
+    /** The wallet address that is allowed to participate */
+    address: `0x${string}`;
+    /** The maximum amount of ETH this address is allowed to contribute (in ETH, not wei) */
+    allowedAmount: number;
+}
+/**
+ * Allowlist proof structure for contract calls
+ */
+interface AllowlistProof {
+    /** The maximum amount of ETH the buyer is allowed to contribute */
+    allowedAmount: bigint;
+    /** Merkle proof bytes32 array */
+    proof: `0x${string}`[];
+}
+/**
+ * Create a Merkle tree from allowlist entries
+ *
+ * @param entries Array of allowlist entries with addresses and allowed amounts
+ * @returns Object containing the Merkle tree, root, and formatted entries
+ *
+ * @example
+ * ```typescript
+ * const entries = [
+ *   { address: '0x123...', allowedAmount: 1.0 }, // 1 ETH max
+ *   { address: '0x456...', allowedAmount: 0.5 }, // 0.5 ETH max
+ * ];
+ * const { root, tree } = createAllowlistMerkleTree(entries);
+ * ```
+ */
+declare function createAllowlistMerkleTree(entries: AllowlistEntry[]): {
+    tree: StandardMerkleTree<[string, string]>;
+    root: `0x${string}`;
+    entries: [string, string][];
+};
+/**
+ * Get a Merkle proof for a specific address in the allowlist
+ *
+ * @param tree The Merkle tree created from allowlist entries
+ * @param entries The formatted entries array from createAllowlistMerkleTree
+ * @param address The address to get a proof for
+ * @param allowedAmount The allowed amount for this address (in ETH)
+ * @returns Array of proof hashes
+ *
+ * @example
+ * ```typescript
+ * const { tree, entries } = createAllowlistMerkleTree(allowlistEntries);
+ * const proof = getAllowlistMerkleProof(tree, entries, '0x123...', 1.0);
+ * ```
+ */
+declare function getAllowlistMerkleProof(tree: StandardMerkleTree<[string, string]>, entries: [string, string][], address: `0x${string}`, allowedAmount: number): `0x${string}`[];
+/**
+ * Encode allowlist initialization data for starting a presale with a merkle root
+ *
+ * @param merkleRoot The merkle root for the allowlist
+ * @returns Encoded bytes for the allowlistInitializationData parameter
+ *
+ * @example
+ * ```typescript
+ * const { root } = createAllowlistMerkleTree(entries);
+ * const initData = encodeAllowlistInitializationData(root);
+ * // Use initData in presaleConfig.allowlistInitializationData
+ * ```
+ */
+declare function encodeAllowlistInitializationData(merkleRoot: `0x${string}`): `0x${string}`;
+/**
+ * Encode allowlist proof data for buying into a presale with proof
+ *
+ * @param allowedAmount The maximum allowed ETH amount for the buyer (in ETH)
+ * @param proof The merkle proof array
+ * @returns Encoded bytes for the proof parameter
+ *
+ * @example
+ * ```typescript
+ * const proof = getAllowlistMerkleProof(tree, entries, buyerAddress, 1.0);
+ * const proofData = encodeAllowlistProofData(1.0, proof);
+ * // Use proofData when calling buyIntoPresaleWithProof
+ * ```
+ */
+declare function encodeAllowlistProofData(allowedAmount: number, proof: `0x${string}`[]): `0x${string}`;
+/**
+ * Get the allowlist contract address for a specific chain
+ *
+ * @param chainId The chain ID
+ * @returns The allowlist contract address, or undefined if not available on this chain
+ */
+declare function getAllowlistAddress(chainId: Chain): `0x${string}` | undefined;
+/**
+ * Get allowlist information for a presale
+ *
+ * @param publicClient The viem public client
+ * @param presaleId The presale ID
+ * @param chainId The chain ID
+ * @returns Allowlist data including presale owner, merkle root, and enabled status
+ */
+declare function getAllowlistInfo(publicClient: PublicClient, presaleId: bigint, chainId: Chain): Promise<{
+    presaleOwner: `0x${string}`;
+    merkleRoot: `0x${string}`;
+    enabled: boolean;
+}>;
+/**
+ * Get the allowed amount for a specific buyer in a presale
+ *
+ * @param publicClient The viem public client
+ * @param presaleId The presale ID
+ * @param buyer The buyer's address
+ * @param proof The encoded proof data (use encodeAllowlistProofData or pass '0x' for no proof)
+ * @param chainId The chain ID
+ * @returns The allowed amount in wei (returns max uint256 if allowlist is disabled)
+ */
+declare function getAllowedAmountForBuyer(publicClient: PublicClient, presaleId: bigint, buyer: `0x${string}`, proof: `0x${string}`, chainId: Chain): Promise<bigint>;
+/**
+ * Helper to verify if a buyer is allowed to purchase a specific amount
+ *
+ * @param publicClient The viem public client
+ * @param presaleId The presale ID
+ * @param buyer The buyer's address
+ * @param desiredAmount The amount the buyer wants to purchase (in ETH)
+ * @param proof The encoded proof data
+ * @param chainId The chain ID
+ * @returns Object with isAllowed boolean and allowedAmount in ETH
+ */
+declare function verifyBuyerAllowance(publicClient: PublicClient, presaleId: bigint, buyer: `0x${string}`, desiredAmount: number, proof: `0x${string}`, chainId: Chain): Promise<{
+    isAllowed: boolean;
+    allowedAmountEth: number;
+    allowedAmountWei: bigint;
+}>;
+
+export { A0X_ADDRESS, ANON_ADDRESS, type AirdropEntry, type AllowlistEntry, type AllowlistProof, CB_BTC_ADDRESS, CLANKER_ADDRESS, Chain, ClankerDeployment, ClankerTokenV4, DEFAULT_SUPPLY, DEGEN_ADDRESS, FEE_CONFIGS, FeeConfigs, HIGHER_ADDRESS, NATIVE_ADDRESS, POOL_POSITIONS, PoolPositions, WETH_ADDRESSES, createAllowlistMerkleTree, createMerkleTree, encodeAirdropData, encodeAllowlistInitializationData, encodeAllowlistProofData, findVanityAddress, findVanityAddressV4, getAllowedAmountForBuyer, getAllowlistAddress, getAllowlistInfo, getAllowlistMerkleProof, getMerkleProof, getTickFromMarketCap, getTickFromMarketCapUSDC, predictTokenAddressV4, verifyBuyerAllowance };

package/dist/index.js

@@ -5840,6 +5840,225 @@ function encodeAirdropData(merkleRoot, lockupDuration, vestingDuration) {
     [merkleRoot, BigInt(lockupDuration), BigInt(vestingDuration)]
   );
 }
+
+// src/utils/presale-allowlist.ts
+import { StandardMerkleTree as StandardMerkleTree2 } from "@openzeppelin/merkle-tree";
+import { encodeAbiParameters as encodeAbiParameters3 } from "viem";
+
+// src/abi/v4.1/ClankerPresaleAllowlist.ts
+var Clanker_PresaleAllowlist_v4_1_abi = [
+  {
+    type: "constructor",
+    inputs: [{ name: "presale_", type: "address", internalType: "address" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "allowlists",
+    inputs: [{ name: "presaleId", type: "uint256", internalType: "uint256" }],
+    outputs: [
+      { name: "presaleOwner", type: "address", internalType: "address" },
+      { name: "merkleRoot", type: "bytes32", internalType: "bytes32" },
+      { name: "enabled", type: "bool", internalType: "bool" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getAllowedAmountForBuyer",
+    inputs: [
+      { name: "presaleId", type: "uint256", internalType: "uint256" },
+      { name: "buyer", type: "address", internalType: "address" },
+      { name: "proof", type: "bytes", internalType: "bytes" }
+    ],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "initialize",
+    inputs: [
+      { name: "presaleId", type: "uint256", internalType: "uint256" },
+      { name: "presaleOwner", type: "address", internalType: "address" },
+      { name: "initializationData", type: "bytes", internalType: "bytes" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "presale",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "setAddressOverride",
+    inputs: [
+      { name: "presaleId", type: "uint256", internalType: "uint256" },
+      { name: "buyer", type: "address", internalType: "address" },
+      { name: "allowedAmount", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setAllowlistEnabled",
+    inputs: [
+      { name: "presaleId", type: "uint256", internalType: "uint256" },
+      { name: "enabled", type: "bool", internalType: "bool" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setMerkleRoot",
+    inputs: [
+      { name: "presaleId", type: "uint256", internalType: "uint256" },
+      { name: "merkleRoot", type: "bytes32", internalType: "bytes32" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "event",
+    name: "Initialize",
+    inputs: [
+      { name: "presaleId", type: "uint256", indexed: true, internalType: "uint256" },
+      { name: "presaleOwner", type: "address", indexed: true, internalType: "address" },
+      { name: "merkleRoot", type: "bytes32", indexed: false, internalType: "bytes32" }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "SetAddressOverride",
+    inputs: [
+      { name: "presaleId", type: "uint256", indexed: true, internalType: "uint256" },
+      { name: "buyer", type: "address", indexed: true, internalType: "address" },
+      { name: "allowedAmount", type: "uint256", indexed: false, internalType: "uint256" }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "SetAllowlistEnabled",
+    inputs: [
+      { name: "presaleId", type: "uint256", indexed: true, internalType: "uint256" },
+      { name: "enabled", type: "bool", indexed: false, internalType: "bool" }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "SetMerkleRoot",
+    inputs: [
+      { name: "presaleId", type: "uint256", indexed: true, internalType: "uint256" },
+      { name: "merkleRoot", type: "bytes32", indexed: false, internalType: "bytes32" }
+    ],
+    anonymous: false
+  },
+  { type: "error", name: "InvalidProof", inputs: [] },
+  { type: "error", name: "MerkleRootNotSet", inputs: [] },
+  { type: "error", name: "Unauthorized", inputs: [] }
+];
+
+// src/utils/presale-allowlist.ts
+function createAllowlistMerkleTree(entries) {
+  const values = entries.map((entry) => [
+    entry.address.toLowerCase(),
+    BigInt(entry.allowedAmount * 1e18).toString()
+    // Convert ETH to wei
+  ]);
+  const tree = StandardMerkleTree2.of(values, ["address", "uint256"]);
+  const root = tree.root;
+  return { tree, root, entries: values };
+}
+function getAllowlistMerkleProof(tree, entries, address, allowedAmount) {
+  const allowedAmountInWei = BigInt(allowedAmount * 1e18);
+  const leaf = [address.toLowerCase(), allowedAmountInWei.toString()];
+  const index = entries.findIndex(([addr, amt]) => addr === leaf[0] && amt === leaf[1]);
+  if (index === -1) {
+    throw new Error(`Entry not found in allowlist Merkle tree for address ${address}`);
+  }
+  const proof = tree.getProof(index);
+  return proof.map((p) => p);
+}
+function encodeAllowlistInitializationData(merkleRoot) {
+  return encodeAbiParameters3([{ type: "bytes32", name: "merkleRoot" }], [merkleRoot]);
+}
+function encodeAllowlistProofData(allowedAmount, proof) {
+  const allowedAmountInWei = BigInt(allowedAmount * 1e18);
+  return encodeAbiParameters3(
+    [
+      {
+        type: "tuple",
+        components: [
+          { name: "allowedAmount", type: "uint256" },
+          { name: "proof", type: "bytes32[]" }
+        ]
+      }
+    ],
+    [
+      {
+        allowedAmount: allowedAmountInWei,
+        proof
+      }
+    ]
+  );
+}
+function getAllowlistAddress(chainId) {
+  const config = clankerConfigFor(chainId, "clanker_v4");
+  return config?.related?.presaleAllowlist;
+}
+async function getAllowlistInfo(publicClient, presaleId, chainId) {
+  const allowlistAddress = getAllowlistAddress(chainId);
+  if (!allowlistAddress) {
+    throw new Error(`Allowlist contract not available on chain ${chainId}`);
+  }
+  const result = await publicClient.readContract({
+    address: allowlistAddress,
+    abi: Clanker_PresaleAllowlist_v4_1_abi,
+    functionName: "allowlists",
+    args: [presaleId]
+  });
+  return {
+    presaleOwner: result[0],
+    merkleRoot: result[1],
+    enabled: result[2]
+  };
+}
+async function getAllowedAmountForBuyer(publicClient, presaleId, buyer, proof, chainId) {
+  const allowlistAddress = getAllowlistAddress(chainId);
+  if (!allowlistAddress) {
+    throw new Error(`Allowlist contract not available on chain ${chainId}`);
+  }
+  return publicClient.readContract({
+    address: allowlistAddress,
+    abi: Clanker_PresaleAllowlist_v4_1_abi,
+    functionName: "getAllowedAmountForBuyer",
+    args: [presaleId, buyer, proof]
+  });
+}
+async function verifyBuyerAllowance(publicClient, presaleId, buyer, desiredAmount, proof, chainId) {
+  const allowedAmountWei = await getAllowedAmountForBuyer(
+    publicClient,
+    presaleId,
+    buyer,
+    proof,
+    chainId
+  );
+  const allowedAmountEth = Number(allowedAmountWei) / 1e18;
+  const isAllowed = desiredAmount <= allowedAmountEth;
+  return {
+    isAllowed,
+    allowedAmountEth,
+    allowedAmountWei
+  };
+}
 export {
   A0X_ADDRESS,
   ANON_ADDRESS,
@@ -5858,12 +6077,20 @@ export {
   PoolPositions,
   WETH_ADDRESSES,
   clankerConfigFor,
+  createAllowlistMerkleTree,
   createMerkleTree,
   encodeAirdropData,
+  encodeAllowlistInitializationData,
+  encodeAllowlistProofData,
   findVanityAddress,
   findVanityAddressV4,
+  getAllowedAmountForBuyer,
+  getAllowlistAddress,
+  getAllowlistInfo,
+  getAllowlistMerkleProof,
   getMerkleProof,
   getTickFromMarketCap,
   getTickFromMarketCapUSDC,
-  predictTokenAddressV4
+  predictTokenAddressV4,
+  verifyBuyerAllowance
 };

package/dist/v3/index.d.ts

@@ -1,4 +1,4 @@
-import { C as ClankerTransactionConfig, a as Clanker_v3_1_abi, b as ClankerFactory, c as ClankerResult } from '../write-clanker-contracts-B4LSHPv2.js';
+import { C as ClankerTransactionConfig, a as Clanker_v3_1_abi, b as ClankerFactory, c as ClankerResult } from '../write-clanker-contracts-CQTURFDk.js';
 import * as viem from 'viem';
 import { WalletClient, Transport, Chain, Account, PublicClient } from 'viem';
 import { C as ClankerToken_v3_1_abi } from '../ClankerToken-Dra5lppJ.js';

package/dist/v4/extensions/index.d.ts

@@ -1,4 +1,4 @@
-import { C as ClankerTransactionConfig, f as ClankerAirdrop_v4_abi, c as ClankerResult, g as Clanker_PresaleEthToCreator_v4_1_abi } from '../../write-clanker-contracts-B4LSHPv2.js';
+import { C as ClankerTransactionConfig, f as ClankerAirdrop_v4_abi, c as ClankerResult, g as Clanker_PresaleEthToCreator_v4_1_abi, h as Clanker_PresaleAllowlist_v4_1_abi } from '../../write-clanker-contracts-CQTURFDk.js';
 import { MerkleTree } from '@openzeppelin/merkle-tree/dist/merkletree.js';
 import * as z from 'zod/v4';
 import { a as Chain, C as ClankerTokenV4 } from '../../clankerTokenV4-xiAq6G4R.js';
@@ -490,5 +490,195 @@ declare function withdrawFromPresale(data: {
  * @returns The allowlist contract address, or undefined if not available
  */
 declare function getAllowlistAddress(chainId: Chain): `0x${string}` | undefined;
+/**
+ * Get a transaction to buy into a presale with allowlist proof
+ *
+ * Use this when buying into a presale that has an allowlist enabled.
+ * The proof must contain your allowlist proof data (merkle proof + allowed amount).
+ *
+ * @param presaleId The ID of the presale
+ * @param chainId The chain ID
+ * @param value The ETH amount to send (in wei)
+ * @param proof The encoded proof data from encodeAllowlistProofData
+ * @returns Transaction configuration for buying into a presale with proof
+ */
+declare function getBuyIntoPresaleWithProofTransaction({ presaleId, chainId, value, proof, }: {
+    presaleId: bigint;
+    chainId: Chain;
+    value: bigint;
+    proof: `0x${string}`;
+}): ClankerTransactionConfig<typeof Clanker_PresaleEthToCreator_v4_1_abi, 'buyIntoPresaleWithProof'>;
+/**
+ * Buy into a presale with allowlist proof
+ *
+ * Use this when buying into a presale that has an allowlist enabled.
+ * You must provide proof that your address is on the allowlist.
+ *
+ * @param clanker Clanker object used for buying into presale
+ * @param presaleId The ID of the presale
+ * @param ethAmount The ETH amount to send (in ETH, will be converted to wei)
+ * @param proof The encoded proof data from encodeAllowlistProofData
+ * @returns Outcome of the transaction
+ *
+ * @example
+ * ```typescript
+ * import { createAllowlistMerkleTree, getAllowlistMerkleProof, encodeAllowlistProofData } from '../utils/presale-allowlist';
+ *
+ * // Get your proof from the allowlist
+ * const { tree, entries } = createAllowlistMerkleTree(allowlistEntries);
+ * const proof = getAllowlistMerkleProof(tree, entries, buyerAddress, 1.0);
+ * const proofData = encodeAllowlistProofData(1.0, proof);
+ *
+ * // Buy with proof
+ * await buyIntoPresaleWithProof({ clanker, presaleId: 1n, ethAmount: 0.5, proof: proofData });
+ * ```
+ */
+declare function buyIntoPresaleWithProof(data: {
+    clanker: Clanker;
+    presaleId: bigint;
+    ethAmount: number;
+    proof: `0x${string}`;
+}): ClankerResult<{
+    txHash: `0x${string}`;
+}>;
+
+/**
+ * Get a transaction to set the merkle root for a presale allowlist
+ *
+ * Only callable by the presale owner. This allows updating the allowlist
+ * after the presale has been created.
+ *
+ * @param presaleId The presale ID
+ * @param merkleRoot The new merkle root
+ * @param chainId The chain ID
+ * @returns Transaction configuration
+ */
+declare function getSetMerkleRootTransaction({ presaleId, merkleRoot, chainId, }: {
+    presaleId: bigint;
+    merkleRoot: `0x${string}`;
+    chainId: Chain;
+}): ClankerTransactionConfig<typeof Clanker_PresaleAllowlist_v4_1_abi, 'setMerkleRoot'>;
+/**
+ * Set the merkle root for a presale allowlist
+ *
+ * Only callable by the presale owner. This allows updating the allowlist
+ * after the presale has been created.
+ *
+ * @param clanker Clanker object
+ * @param presaleId The presale ID
+ * @param merkleRoot The new merkle root
+ * @returns Outcome of the transaction
+ */
+declare function setMerkleRoot(data: {
+    clanker: Clanker;
+    presaleId: bigint;
+    merkleRoot: `0x${string}`;
+}): ClankerResult<{
+    txHash: `0x${string}`;
+}>;
+/**
+ * Get a transaction to set an address override for a presale allowlist
+ *
+ * Only callable by the presale owner. Address overrides take precedence
+ * over the merkle tree allowlist. Setting allowedAmount to 0 effectively
+ * removes the override.
+ *
+ * @param presaleId The presale ID
+ * @param buyer The buyer's address to override
+ * @param allowedAmount The allowed amount in wei (0 to remove override)
+ * @param chainId The chain ID
+ * @returns Transaction configuration
+ */
+declare function getSetAddressOverrideTransaction({ presaleId, buyer, allowedAmount, chainId, }: {
+    presaleId: bigint;
+    buyer: `0x${string}`;
+    allowedAmount: bigint;
+    chainId: Chain;
+}): ClankerTransactionConfig<typeof Clanker_PresaleAllowlist_v4_1_abi, 'setAddressOverride'>;
+/**
+ * Set an address override for a presale allowlist
+ *
+ * Only callable by the presale owner. Address overrides take precedence
+ * over the merkle tree allowlist. This is useful for manually adding
+ * addresses without regenerating the entire merkle tree.
+ *
+ * @param clanker Clanker object
+ * @param presaleId The presale ID
+ * @param buyer The buyer's address to override
+ * @param allowedAmountEth The allowed amount in ETH (0 to remove override)
+ * @returns Outcome of the transaction
+ *
+ * @example
+ * ```typescript
+ * // Allow a specific address to buy up to 2 ETH
+ * await setAddressOverride({
+ *   clanker,
+ *   presaleId: 1n,
+ *   buyer: '0x123...',
+ *   allowedAmountEth: 2.0
+ * });
+ *
+ * // Remove the override (set to 0)
+ * await setAddressOverride({
+ *   clanker,
+ *   presaleId: 1n,
+ *   buyer: '0x123...',
+ *   allowedAmountEth: 0
+ * });
+ * ```
+ */
+declare function setAddressOverride(data: {
+    clanker: Clanker;
+    presaleId: bigint;
+    buyer: `0x${string}`;
+    allowedAmountEth: number;
+}): ClankerResult<{
+    txHash: `0x${string}`;
+}>;
+/**
+ * Get a transaction to enable or disable the allowlist for a presale
+ *
+ * Only callable by the presale owner. When disabled, anyone can buy
+ * into the presale without restrictions. When enabled, buyers must
+ * provide proof or have an address override.
+ *
+ * @param presaleId The presale ID
+ * @param enabled Whether to enable or disable the allowlist
+ * @param chainId The chain ID
+ * @returns Transaction configuration
+ */
+declare function getSetAllowlistEnabledTransaction({ presaleId, enabled, chainId, }: {
+    presaleId: bigint;
+    enabled: boolean;
+    chainId: Chain;
+}): ClankerTransactionConfig<typeof Clanker_PresaleAllowlist_v4_1_abi, 'setAllowlistEnabled'>;
+/**
+ * Enable or disable the allowlist for a presale
+ *
+ * Only callable by the presale owner. When disabled, anyone can buy
+ * into the presale without restrictions. When enabled, buyers must
+ * provide proof or have an address override.
+ *
+ * @param clanker Clanker object
+ * @param presaleId The presale ID
+ * @param enabled Whether to enable or disable the allowlist
+ * @returns Outcome of the transaction
+ *
+ * @example
+ * ```typescript
+ * // Disable the allowlist to let anyone participate
+ * await setAllowlistEnabled({ clanker, presaleId: 1n, enabled: false });
+ *
+ * // Re-enable the allowlist
+ * await setAllowlistEnabled({ clanker, presaleId: 1n, enabled: true });
+ * ```
+ */
+declare function setAllowlistEnabled(data: {
+    clanker: Clanker;
+    presaleId: bigint;
+    enabled: boolean;
+}): ClankerResult<{
+    txHash: `0x${string}`;
+}>;
 
-export { type AirdropRecipient, type PresaleConfig, PresaleStatus, buyIntoPresale, claimAirdrop, claimEth, claimTokens, createAirdrop, endPresale, fetchAirdropProofs, getAirdropProofs, getAllowlistAddress, getAmountAvailableToClaim, getBuyIntoPresaleTransaction, getClaimAirdropTransaction, getClaimEthTransaction, getClaimTokensTransaction, getEndPresaleTransaction, getPresale, getPresaleBuys, getPresaleClaimed, getPresaleState, getStartPresaleTransaction, getWithdrawFromPresaleTransaction, registerAirdrop, startPresale, withdrawFromPresale };
+export { type AirdropRecipient, type PresaleConfig, PresaleStatus, buyIntoPresale, buyIntoPresaleWithProof, claimAirdrop, claimEth, claimTokens, createAirdrop, endPresale, fetchAirdropProofs, getAirdropProofs, getAllowlistAddress, getAmountAvailableToClaim, getBuyIntoPresaleTransaction, getBuyIntoPresaleWithProofTransaction, getClaimAirdropTransaction, getClaimEthTransaction, getClaimTokensTransaction, getEndPresaleTransaction, getPresale, getPresaleBuys, getPresaleClaimed, getPresaleState, getSetAddressOverrideTransaction, getSetAllowlistEnabledTransaction, getSetMerkleRootTransaction, getStartPresaleTransaction, getWithdrawFromPresaleTransaction, registerAirdrop, setAddressOverride, setAllowlistEnabled, setMerkleRoot, startPresale, withdrawFromPresale };

package/dist/v4/extensions/index.js

@@ -7844,9 +7844,248 @@ function getAllowlistAddress(chainId) {
   const config = clankerConfigFor(chainId, "clanker_v4");
   return config?.related?.presaleAllowlist;
 }
+function getBuyIntoPresaleWithProofTransaction({
+  presaleId,
+  chainId,
+  value,
+  proof
+}) {
+  const config = clankerConfigFor(chainId, "clanker_v4");
+  if (!config?.related?.presale) {
+    throw new Error(`PresaleEthToCreator is not available on chain ${chainId}`);
+  }
+  return {
+    chainId,
+    address: config.related.presale,
+    abi: Clanker_PresaleEthToCreator_v4_1_abi,
+    functionName: "buyIntoPresaleWithProof",
+    args: [presaleId, proof],
+    value
+  };
+}
+function buyIntoPresaleWithProof(data) {
+  if (!data.clanker.publicClient) throw new Error("Public client required on clanker");
+  if (!data.clanker.wallet) throw new Error("Wallet client required on clanker");
+  const tx = getBuyIntoPresaleWithProofTransaction({
+    presaleId: data.presaleId,
+    chainId: data.clanker.wallet.chain.id,
+    value: BigInt(data.ethAmount * 1e18),
+    // Convert ETH to wei
+    proof: data.proof
+  });
+  return writeClankerContract(data.clanker.publicClient, data.clanker.wallet, tx);
+}
+
+// src/abi/v4.1/ClankerPresaleAllowlist.ts
+var Clanker_PresaleAllowlist_v4_1_abi = [
+  {
+    type: "constructor",
+    inputs: [{ name: "presale_", type: "address", internalType: "address" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "allowlists",
+    inputs: [{ name: "presaleId", type: "uint256", internalType: "uint256" }],
+    outputs: [
+      { name: "presaleOwner", type: "address", internalType: "address" },
+      { name: "merkleRoot", type: "bytes32", internalType: "bytes32" },
+      { name: "enabled", type: "bool", internalType: "bool" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getAllowedAmountForBuyer",
+    inputs: [
+      { name: "presaleId", type: "uint256", internalType: "uint256" },
+      { name: "buyer", type: "address", internalType: "address" },
+      { name: "proof", type: "bytes", internalType: "bytes" }
+    ],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "initialize",
+    inputs: [
+      { name: "presaleId", type: "uint256", internalType: "uint256" },
+      { name: "presaleOwner", type: "address", internalType: "address" },
+      { name: "initializationData", type: "bytes", internalType: "bytes" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "presale",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "setAddressOverride",
+    inputs: [
+      { name: "presaleId", type: "uint256", internalType: "uint256" },
+      { name: "buyer", type: "address", internalType: "address" },
+      { name: "allowedAmount", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setAllowlistEnabled",
+    inputs: [
+      { name: "presaleId", type: "uint256", internalType: "uint256" },
+      { name: "enabled", type: "bool", internalType: "bool" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setMerkleRoot",
+    inputs: [
+      { name: "presaleId", type: "uint256", internalType: "uint256" },
+      { name: "merkleRoot", type: "bytes32", internalType: "bytes32" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "event",
+    name: "Initialize",
+    inputs: [
+      { name: "presaleId", type: "uint256", indexed: true, internalType: "uint256" },
+      { name: "presaleOwner", type: "address", indexed: true, internalType: "address" },
+      { name: "merkleRoot", type: "bytes32", indexed: false, internalType: "bytes32" }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "SetAddressOverride",
+    inputs: [
+      { name: "presaleId", type: "uint256", indexed: true, internalType: "uint256" },
+      { name: "buyer", type: "address", indexed: true, internalType: "address" },
+      { name: "allowedAmount", type: "uint256", indexed: false, internalType: "uint256" }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "SetAllowlistEnabled",
+    inputs: [
+      { name: "presaleId", type: "uint256", indexed: true, internalType: "uint256" },
+      { name: "enabled", type: "bool", indexed: false, internalType: "bool" }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "SetMerkleRoot",
+    inputs: [
+      { name: "presaleId", type: "uint256", indexed: true, internalType: "uint256" },
+      { name: "merkleRoot", type: "bytes32", indexed: false, internalType: "bytes32" }
+    ],
+    anonymous: false
+  },
+  { type: "error", name: "InvalidProof", inputs: [] },
+  { type: "error", name: "MerkleRootNotSet", inputs: [] },
+  { type: "error", name: "Unauthorized", inputs: [] }
+];
+
+// src/v4/extensions/presale-allowlist-management.ts
+function getSetMerkleRootTransaction({
+  presaleId,
+  merkleRoot,
+  chainId
+}) {
+  const config = clankerConfigFor(chainId, "clanker_v4");
+  if (!config?.related?.presaleAllowlist) {
+    throw new Error(`Allowlist contract not available on chain ${chainId}`);
+  }
+  return {
+    chainId,
+    address: config.related.presaleAllowlist,
+    abi: Clanker_PresaleAllowlist_v4_1_abi,
+    functionName: "setMerkleRoot",
+    args: [presaleId, merkleRoot]
+  };
+}
+function setMerkleRoot(data) {
+  if (!data.clanker.publicClient) throw new Error("Public client required on clanker");
+  if (!data.clanker.wallet) throw new Error("Wallet client required on clanker");
+  const tx = getSetMerkleRootTransaction({
+    presaleId: data.presaleId,
+    merkleRoot: data.merkleRoot,
+    chainId: data.clanker.wallet.chain.id
+  });
+  return writeClankerContract(data.clanker.publicClient, data.clanker.wallet, tx);
+}
+function getSetAddressOverrideTransaction({
+  presaleId,
+  buyer,
+  allowedAmount,
+  chainId
+}) {
+  const config = clankerConfigFor(chainId, "clanker_v4");
+  if (!config?.related?.presaleAllowlist) {
+    throw new Error(`Allowlist contract not available on chain ${chainId}`);
+  }
+  return {
+    chainId,
+    address: config.related.presaleAllowlist,
+    abi: Clanker_PresaleAllowlist_v4_1_abi,
+    functionName: "setAddressOverride",
+    args: [presaleId, buyer, allowedAmount]
+  };
+}
+function setAddressOverride(data) {
+  if (!data.clanker.publicClient) throw new Error("Public client required on clanker");
+  if (!data.clanker.wallet) throw new Error("Wallet client required on clanker");
+  const tx = getSetAddressOverrideTransaction({
+    presaleId: data.presaleId,
+    buyer: data.buyer,
+    allowedAmount: BigInt(data.allowedAmountEth * 1e18),
+    // Convert ETH to wei
+    chainId: data.clanker.wallet.chain.id
+  });
+  return writeClankerContract(data.clanker.publicClient, data.clanker.wallet, tx);
+}
+function getSetAllowlistEnabledTransaction({
+  presaleId,
+  enabled,
+  chainId
+}) {
+  const config = clankerConfigFor(chainId, "clanker_v4");
+  if (!config?.related?.presaleAllowlist) {
+    throw new Error(`Allowlist contract not available on chain ${chainId}`);
+  }
+  return {
+    chainId,
+    address: config.related.presaleAllowlist,
+    abi: Clanker_PresaleAllowlist_v4_1_abi,
+    functionName: "setAllowlistEnabled",
+    args: [presaleId, enabled]
+  };
+}
+function setAllowlistEnabled(data) {
+  if (!data.clanker.publicClient) throw new Error("Public client required on clanker");
+  if (!data.clanker.wallet) throw new Error("Wallet client required on clanker");
+  const tx = getSetAllowlistEnabledTransaction({
+    presaleId: data.presaleId,
+    enabled: data.enabled,
+    chainId: data.clanker.wallet.chain.id
+  });
+  return writeClankerContract(data.clanker.publicClient, data.clanker.wallet, tx);
+}
 export {
   PresaleStatus,
   buyIntoPresale,
+  buyIntoPresaleWithProof,
   claimAirdrop,
   claimEth,
   claimTokens,
@@ -7857,6 +8096,7 @@ export {
   getAllowlistAddress,
   getAmountAvailableToClaim,
   getBuyIntoPresaleTransaction,
+  getBuyIntoPresaleWithProofTransaction,
   getClaimAirdropTransaction,
   getClaimEthTransaction,
   getClaimTokensTransaction,
@@ -7865,9 +8105,15 @@ export {
   getPresaleBuys,
   getPresaleClaimed,
   getPresaleState,
+  getSetAddressOverrideTransaction,
+  getSetAllowlistEnabledTransaction,
+  getSetMerkleRootTransaction,
   getStartPresaleTransaction,
   getWithdrawFromPresaleTransaction,
   registerAirdrop,
+  setAddressOverride,
+  setAllowlistEnabled,
+  setMerkleRoot,
   startPresale,
   withdrawFromPresale
 };

package/dist/v4/index.d.ts

@@ -1,4 +1,4 @@
-import { C as ClankerTransactionConfig, d as ClankerFeeLocker_abi, b as ClankerFactory, c as ClankerResult, e as ClankerLocker_v4_abi } from '../write-clanker-contracts-B4LSHPv2.js';
+import { C as ClankerTransactionConfig, d as ClankerFeeLocker_abi, b as ClankerFactory, c as ClankerResult, e as ClankerLocker_v4_abi } from '../write-clanker-contracts-CQTURFDk.js';
 import * as viem from 'viem';
 import { WalletClient, Transport, Chain, Account, PublicClient } from 'viem';
 import { a as ClankerToken_v4_abi } from '../ClankerToken-Dra5lppJ.js';

package/dist/{write-clanker-contracts-B4LSHPv2.d.ts → write-clanker-contracts-CQTURFDk.d.ts}

@@ -7455,6 +7455,216 @@ declare const ClankerLocker_v4_abi: readonly [{
     readonly inputs: readonly [];
 }];
 
+declare const Clanker_PresaleAllowlist_v4_1_abi: readonly [{
+    readonly type: "constructor";
+    readonly inputs: readonly [{
+        readonly name: "presale_";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "allowlists";
+    readonly inputs: readonly [{
+        readonly name: "presaleId";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "presaleOwner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "merkleRoot";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "enabled";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getAllowedAmountForBuyer";
+    readonly inputs: readonly [{
+        readonly name: "presaleId";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "buyer";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "proof";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "initialize";
+    readonly inputs: readonly [{
+        readonly name: "presaleId";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "presaleOwner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "initializationData";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "presale";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "setAddressOverride";
+    readonly inputs: readonly [{
+        readonly name: "presaleId";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "buyer";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "allowedAmount";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "setAllowlistEnabled";
+    readonly inputs: readonly [{
+        readonly name: "presaleId";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "enabled";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "setMerkleRoot";
+    readonly inputs: readonly [{
+        readonly name: "presaleId";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "merkleRoot";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "event";
+    readonly name: "Initialize";
+    readonly inputs: readonly [{
+        readonly name: "presaleId";
+        readonly type: "uint256";
+        readonly indexed: true;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "presaleOwner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "merkleRoot";
+        readonly type: "bytes32";
+        readonly indexed: false;
+        readonly internalType: "bytes32";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "SetAddressOverride";
+    readonly inputs: readonly [{
+        readonly name: "presaleId";
+        readonly type: "uint256";
+        readonly indexed: true;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "buyer";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "allowedAmount";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "SetAllowlistEnabled";
+    readonly inputs: readonly [{
+        readonly name: "presaleId";
+        readonly type: "uint256";
+        readonly indexed: true;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "enabled";
+        readonly type: "bool";
+        readonly indexed: false;
+        readonly internalType: "bool";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "SetMerkleRoot";
+    readonly inputs: readonly [{
+        readonly name: "presaleId";
+        readonly type: "uint256";
+        readonly indexed: true;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "merkleRoot";
+        readonly type: "bytes32";
+        readonly indexed: false;
+        readonly internalType: "bytes32";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "error";
+    readonly name: "InvalidProof";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "MerkleRootNotSet";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "Unauthorized";
+    readonly inputs: readonly [];
+}];
+
 declare const Clanker_PresaleEthToCreator_v4_1_abi: readonly [{
     readonly type: "constructor";
     readonly inputs: readonly [{
@@ -9186,7 +9396,7 @@ declare const Clanker_PresaleEthToCreator_v4_1_abi: readonly [{
 type ClankerToken = typeof ClankerToken_v3_1_abi | typeof ClankerToken_v4_abi;
 type ClankerFactory = typeof Clanker_v3_1_abi | typeof Clanker_v4_abi;
 type ClankerHooks = typeof ClankerHook_DynamicFee_v4_abi | typeof ClankerHook_StaticFee_v4_abi;
-type ClankerContract = typeof ClankerFeeLocker_abi | ClankerFactory | ClankerToken | ClankerHooks | typeof ClankerAirdrop_v4_abi | typeof ClankerAirdropv2_v4_abi | typeof LpLockerv2_abi | typeof ClankerLocker_v4_abi | typeof Clanker_PresaleEthToCreator_v4_1_abi | typeof Clanker_v0_abi;
+type ClankerContract = typeof ClankerFeeLocker_abi | ClankerFactory | ClankerToken | ClankerHooks | typeof ClankerAirdrop_v4_abi | typeof ClankerAirdropv2_v4_abi | typeof LpLockerv2_abi | typeof ClankerLocker_v4_abi | typeof Clanker_PresaleAllowlist_v4_1_abi | typeof Clanker_PresaleEthToCreator_v4_1_abi | typeof Clanker_v0_abi;
 
 type UndefinedValues<T> = {
     [P in keyof T]?: undefined;
@@ -9207,4 +9417,4 @@ type ClankerTransactionConfig<abi extends ClankerContract = ClankerContract, fun
     chainId?: number;
 };
 
-export { type ClankerTransactionConfig as C, Clanker_v3_1_abi as a, type ClankerFactory as b, type ClankerResult as c, ClankerFeeLocker_abi as d, ClankerLocker_v4_abi as e, ClankerAirdrop_v4_abi as f, Clanker_PresaleEthToCreator_v4_1_abi as g };
+export { type ClankerTransactionConfig as C, Clanker_v3_1_abi as a, type ClankerFactory as b, type ClankerResult as c, ClankerFeeLocker_abi as d, ClankerLocker_v4_abi as e, ClankerAirdrop_v4_abi as f, Clanker_PresaleEthToCreator_v4_1_abi as g, Clanker_PresaleAllowlist_v4_1_abi as h };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clanker-sdk",
-  "version": "4.2.5",
+  "version": "4.2.6",
   "description": "SDK for deploying tokens using Clanker",
   "type": "module",
   "main": "./dist/index.js",