clanker-sdk 4.2.4 → 4.2.5-canary.0

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

@@ -1,7 +1,7 @@
-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-Btn0ZN4v.js';
+import { a as Chain, C as ClankerTokenV4 } from '../../clankerTokenV4-xiAq6G4R.js';
 import { Clanker } from '../index.js';
 import { C as ClankerError } from '../../errors-5Gv28Tkr.js';
 import 'viem';
@@ -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

@@ -6861,7 +6861,7 @@ var Clanker_PresaleEthToCreator_v4_1_abi = [
 
 // src/config/clankerTokenV4.ts
 import {
-  encodeAbiParameters,
+  encodeAbiParameters as encodeAbiParameters2,
   isAddressEqual as isAddressEqual2,
   stringify as stringify2,
   zeroAddress,
@@ -7069,7 +7069,12 @@ var POOL_POSITIONS = {
 };
 
 // src/services/vanityAddress.ts
-import { encodeDeployData, keccak256 } from "viem";
+import {
+  encodeAbiParameters,
+  encodeDeployData,
+  getContractAddress,
+  keccak256
+} from "viem";
 import { abstract as abstract3, monadTestnet as monadTestnet3 } from "viem/chains";
 var findVanityAddressV4 = async (args, admin, suffix = "0x4b07", config) => {
   const data = encodeDeployData({
@@ -7084,6 +7089,30 @@ var findVanityAddressV4 = async (args, admin, suffix = "0x4b07", config) => {
   const { address, salt } = await response.json();
   return { token: address, salt };
 };
+var predictTokenAddressV4 = (args, config, salt, tokenAdmin) => {
+  const deployData = encodeDeployData({
+    abi: config.token.abi,
+    bytecode: config.token.bytecode,
+    args
+  });
+  const actualSalt = keccak256(
+    encodeAbiParameters(
+      [
+        { type: "address", name: "tokenAdmin" },
+        { type: "bytes32", name: "salt" }
+      ],
+      [tokenAdmin, salt]
+    )
+  );
+  const predictedAddress = getContractAddress({
+    from: config.address,
+    // deployer (Clanker contract)
+    salt: actualSalt,
+    bytecode: deployData,
+    opcode: "CREATE2"
+  });
+  return predictedAddress;
+};
 
 // src/config/clankerTokenV4.ts
 var NULL_DEVBUY_POOL_CONFIG = {
@@ -7108,6 +7137,8 @@ var clankerTokenV4 = z3.strictObject({
   image: z3.string().default(""),
   /** Id of the chain that the token will be deployed to. Defaults to base (8453). */
   chainId: z3.literal(Chains).default(8453),
+  /** Custom salt for CREATE2 deployment. If provided, this will be used instead of vanity address generation. Takes precedence over vanity. */
+  salt: hexSchema.optional(),
   /** Admin for the token. They will be able to change fields like image, metadata, etc. */
   tokenAdmin: addressSchema.refine((v) => !isAddressEqual2(v, zeroAddress), {
     error: "Admin cannot be zero address"
@@ -7311,23 +7342,24 @@ var clankerTokenV4Converter = async (config) => {
   if (cfg.presale && !clankerConfig?.related?.presale) {
     throw new Error(`Presales are not available on chain ${cfg.chainId}`);
   }
-  const { salt, token: expectedAddress } = cfg.vanity ? await findVanityAddressV4(
-    [
-      cfg.name,
-      cfg.symbol,
-      DEFAULT_SUPPLY,
-      cfg.tokenAdmin,
-      cfg.image,
-      metadata,
-      socialContext,
-      BigInt(cfg.chainId)
-    ],
+  const tokenArgs = [
+    cfg.name,
+    cfg.symbol,
+    DEFAULT_SUPPLY,
     cfg.tokenAdmin,
-    "0x4b07",
-    clankerConfig
-  ) : {
+    cfg.image,
+    metadata,
+    socialContext,
+    BigInt(cfg.chainId)
+  ];
+  const { salt, token: expectedAddress } = cfg.salt ? {
+    // Use custom salt if provided, predict the address using CREATE2
+    salt: cfg.salt,
+    token: predictTokenAddressV4(tokenArgs, clankerConfig, cfg.salt, cfg.tokenAdmin)
+  } : cfg.vanity ? await findVanityAddressV4(tokenArgs, cfg.tokenAdmin, "0x4b07", clankerConfig) : {
+    // Default case: use zeroHash and predict address
     salt: zeroHash,
-    token: void 0
+    token: predictTokenAddressV4(tokenArgs, clankerConfig, zeroHash, cfg.tokenAdmin)
   };
   const airdropAmount = BigInt(cfg.airdrop?.amount || 0) * BigInt(1e18);
   const bpsAirdropped = airdropAmount * 10000n / DEFAULT_SUPPLY + (airdropAmount * 10000n % DEFAULT_SUPPLY ? 1n : 0n);
@@ -7363,7 +7395,7 @@ var clankerTokenV4Converter = async (config) => {
         },
         lockerConfig: {
           locker: cfg.locker.locker === "Locker" ? clankerConfig.related.locker : cfg.locker.locker,
-          lockerData: encodeAbiParameters(ClankerLpLocker_Instantiation_v4_abi, [
+          lockerData: encodeAbiParameters2(ClankerLpLocker_Instantiation_v4_abi, [
             {
               feePreference: cfg.rewards.recipients.map(({ token }) => FeeInToInt[token])
             }
@@ -7384,7 +7416,7 @@ var clankerTokenV4Converter = async (config) => {
         },
         mevModuleConfig: {
           mevModule: clankerConfig.related?.mevModuleV2 || clankerConfig.related?.mevModule,
-          mevModuleData: clankerConfig.related?.mevModuleV2 ? encodeAbiParameters(Clanker_MevSniperAuction_InitData_v4_1_abi, [
+          mevModuleData: clankerConfig.related?.mevModuleV2 ? encodeAbiParameters2(Clanker_MevSniperAuction_InitData_v4_1_abi, [
             {
               startingFee: cfg.sniperFees.startingFee,
               endingFee: cfg.sniperFees.endingFee,
@@ -7399,7 +7431,7 @@ var clankerTokenV4Converter = async (config) => {
               extension: clankerConfig.related.vault,
               msgValue: 0n,
               extensionBps: cfg.vault.percentage * 100,
-              extensionData: encodeAbiParameters(ClankerVault_Instantiation_v4_abi, [
+              extensionData: encodeAbiParameters2(ClankerVault_Instantiation_v4_abi, [
                 cfg.vault.recipient ?? cfg.tokenAdmin,
                 BigInt(cfg.vault.lockupDuration),
                 BigInt(cfg.vault.vestingDuration)
@@ -7412,7 +7444,7 @@ var clankerTokenV4Converter = async (config) => {
               extension: clankerConfig.related.airdrop,
               msgValue: 0n,
               extensionBps: Number(bpsAirdropped),
-              extensionData: encodeAbiParameters(ClankerAirdropV2_Instantiation_v4_abi, [
+              extensionData: encodeAbiParameters2(ClankerAirdropV2_Instantiation_v4_abi, [
                 cfg.airdrop.admin || cfg.tokenAdmin,
                 cfg.airdrop.merkleRoot,
                 BigInt(cfg.airdrop.lockupDuration),
@@ -7426,7 +7458,7 @@ var clankerTokenV4Converter = async (config) => {
               extension: clankerConfig.related.devbuy,
               msgValue: BigInt(cfg.devBuy.ethAmount * 1e18),
               extensionBps: 0,
-              extensionData: encodeAbiParameters(ClankerUniV4EthDevBuy_Instantiation_v4_abi, [
+              extensionData: encodeAbiParameters2(ClankerUniV4EthDevBuy_Instantiation_v4_abi, [
                 cfg.devBuy.poolKey,
                 BigInt(cfg.devBuy.amountOutMin * 1e18),
                 cfg.tokenAdmin
@@ -7454,7 +7486,7 @@ var clankerTokenV4Converter = async (config) => {
 function encodeFeeConfig(tokenConfig, clankerConfig) {
   const config = tokenConfig.fees;
   if (config.type === "static") {
-    const feeData = encodeAbiParameters(ClankerHook_StaticFee_Instantiation_v4_abi, [
+    const feeData = encodeAbiParameters2(ClankerHook_StaticFee_Instantiation_v4_abi, [
       config.clankerFee * 100,
       // uniBps
       config.pairedFee * 100
@@ -7463,7 +7495,7 @@ function encodeFeeConfig(tokenConfig, clankerConfig) {
     if (clankerConfig.related.feeStaticHookV2) {
       return {
         hook: clankerConfig.related.feeStaticHookV2,
-        poolData: encodeAbiParameters(Clanker_PoolInitializationData_v4_1_abi, [
+        poolData: encodeAbiParameters2(Clanker_PoolInitializationData_v4_1_abi, [
           {
             extension: tokenConfig.poolExtension.address,
             extensionData: tokenConfig.poolExtension.initData,
@@ -7478,7 +7510,7 @@ function encodeFeeConfig(tokenConfig, clankerConfig) {
     };
   }
   if (config.type === "dynamic") {
-    const feeData = encodeAbiParameters(ClankerHook_DynamicFee_Instantiation_v4_abi, [
+    const feeData = encodeAbiParameters2(ClankerHook_DynamicFee_Instantiation_v4_abi, [
       config.baseFee * 100,
       // uniBps
       config.maxFee * 100,
@@ -7492,7 +7524,7 @@ function encodeFeeConfig(tokenConfig, clankerConfig) {
     if (clankerConfig.related.feeDynamicHookV2) {
       return {
         hook: clankerConfig.related.feeDynamicHookV2,
-        poolData: encodeAbiParameters(Clanker_PoolInitializationData_v4_1_abi, [
+        poolData: encodeAbiParameters2(Clanker_PoolInitializationData_v4_1_abi, [
           {
             extension: tokenConfig.poolExtension.address,
             extensionData: tokenConfig.poolExtension.initData,
@@ -7812,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,
@@ -7825,6 +8096,7 @@ export {
   getAllowlistAddress,
   getAmountAvailableToClaim,
   getBuyIntoPresaleTransaction,
+  getBuyIntoPresaleWithProofTransaction,
   getClaimAirdropTransaction,
   getClaimEthTransaction,
   getClaimTokensTransaction,
@@ -7833,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,9 +1,9 @@
-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';
-import { C as ClankerTokenV4 } from '../clankerTokenV4-Btn0ZN4v.js';
-export { e as encodeFeeConfig } from '../clankerTokenV4-Btn0ZN4v.js';
+import { C as ClankerTokenV4 } from '../clankerTokenV4-xiAq6G4R.js';
+export { e as encodeFeeConfig } from '../clankerTokenV4-xiAq6G4R.js';
 import { C as ClankerError } from '../errors-5Gv28Tkr.js';
 import 'zod/v4';