clanker-sdk 4.2.4 → 4.2.5-canary.0

package/dist/{clankerTokenV4-Btn0ZN4v.d.ts → clankerTokenV4-xiAq6G4R.d.ts}

@@ -18015,6 +18015,8 @@ declare const clankerTokenV4: z.ZodObject<{
     image: z.ZodDefault<z.ZodString>;
     /** Id of the chain that the token will be deployed to. Defaults to base (8453). */
     chainId: z.ZodDefault<z.ZodLiteral<1 | 143 | 8453 | 10143 | 2741 | 84532 | 42161 | 130>>;
+    /** Custom salt for CREATE2 deployment. If provided, this will be used instead of vanity address generation. Takes precedence over vanity. */
+    salt: z.ZodOptional<z.ZodCustom<`0x${string}`, `0x${string}`>>;
     /** Admin for the token. They will be able to change fields like image, metadata, etc. */
     tokenAdmin: z.ZodCustom<`0x${string}`, `0x${string}`>;
     /** Metadata for the token. */

package/dist/cli/cli.js

@@ -9,12 +9,12 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// node_modules/.pnpm/tsup@8.4.0_typescript@5.8.3/node_modules/tsup/assets/esm_shims.js
+// node_modules/tsup/assets/esm_shims.js
 import { fileURLToPath } from "url";
 import path from "path";
 var getFilename, getDirname, __dirname;
 var init_esm_shims = __esm({
-  "node_modules/.pnpm/tsup@8.4.0_typescript@5.8.3/node_modules/tsup/assets/esm_shims.js"() {
+  "node_modules/tsup/assets/esm_shims.js"() {
     "use strict";
     getFilename = () => fileURLToPath(import.meta.url);
     getDirname = () => path.dirname(getFilename());
@@ -6282,7 +6282,12 @@ var init_clankers = __esm({
 });
 
 // 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 findVanityAddress;
 var init_vanityAddress = __esm({

package/dist/cli/create-clanker.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// node_modules/.pnpm/tsup@8.4.0_typescript@5.8.3/node_modules/tsup/assets/esm_shims.js
+// node_modules/tsup/assets/esm_shims.js
 import { fileURLToPath } from "url";
 import path from "path";
 var getFilename = () => fileURLToPath(import.meta.url);
@@ -3137,7 +3137,12 @@ var WETH_ADDRESSES = {
 var DEFAULT_SUPPLY = 100000000000000000000000000000n;
 
 // 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";
 
 // src/utils/clankers.ts

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-Btn0ZN4v.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-Btn0ZN4v.js';
-import { ContractConstructorArgs } from 'viem';
+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, 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';
@@ -43,6 +43,19 @@ declare const findVanityAddressV4: (args: ContractConstructorArgs<typeof Clanker
     salt: `0x${string}`;
     token: `0x${string}`;
 }>;
+/**
+ * Predict the token address for a V4 deployment with a custom salt using CREATE2.
+ *
+ * The Clanker contract uses: keccak256(abi.encode(tokenAdmin, salt))
+ * as the actual CREATE2 salt.
+ *
+ * @param args Constructor arguments for the token
+ * @param config Clanker deployment configuration
+ * @param salt Custom salt for CREATE2 deployment
+ * @param tokenAdmin Token admin address (used to derive the actual CREATE2 salt)
+ * @returns The predicted token address
+ */
+declare const predictTokenAddressV4: (args: ContractConstructorArgs<typeof ClankerToken_v4_abi>, config: ClankerDeployment, salt: Hex, tokenAdmin: `0x${string}`) => `0x${string}`;
 
 /**
  * Calculate starting tick and spacing for a token pooled against ETH.
@@ -82,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 };
+/**
+ * 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

@@ -206,7 +206,12 @@ var FEE_CONFIGS = {
 };
 
 // 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";
 
 // src/abi/v3.1/ClankerToken.ts
@@ -5759,6 +5764,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/utils/market-cap.ts
 var getTickFromMarketCap = (marketCap) => {
@@ -5781,7 +5810,7 @@ function getTickFromMarketCapUSDC(marketCapUSDC, tickSpacing = 200) {
 
 // src/utils/merkleTree.ts
 import { StandardMerkleTree } from "@openzeppelin/merkle-tree";
-import { encodeAbiParameters } from "viem";
+import { encodeAbiParameters as encodeAbiParameters2 } from "viem";
 var TOKEN_DECIMALS = 18n;
 function toTokenDecimals(amount) {
   return BigInt(amount) * 10n ** TOKEN_DECIMALS;
@@ -5806,11 +5835,230 @@ function getMerkleProof(tree, entries, account, amount) {
   return proof.map((p) => p);
 }
 function encodeAirdropData(merkleRoot, lockupDuration, vestingDuration) {
-  return encodeAbiParameters(
+  return encodeAbiParameters2(
     [{ type: "bytes32" }, { type: "uint256" }, { type: "uint256" }],
     [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,
@@ -5829,11 +6077,20 @@ export {
   PoolPositions,
   WETH_ADDRESSES,
   clankerConfigFor,
+  createAllowlistMerkleTree,
   createMerkleTree,
   encodeAirdropData,
+  encodeAllowlistInitializationData,
+  encodeAllowlistProofData,
   findVanityAddress,
   findVanityAddressV4,
+  getAllowedAmountForBuyer,
+  getAllowlistAddress,
+  getAllowlistInfo,
+  getAllowlistMerkleProof,
   getMerkleProof,
   getTickFromMarketCap,
-  getTickFromMarketCapUSDC
+  getTickFromMarketCapUSDC,
+  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/v3/index.js

@@ -3119,7 +3119,12 @@ var WETH_ADDRESSES = {
 var DEFAULT_SUPPLY = 100000000000000000000000000000n;
 
 // 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";
 
 // src/utils/clankers.ts