clanker-sdk 4.2.1 → 4.2.3-canary.0

package/dist/legacyFeeClaims/index.js

@@ -0,0 +1,685 @@
+// src/legacyFeeClaims/index.ts
+import { StandardMerkleTree } from "@openzeppelin/merkle-tree";
+import { keccak256 } from "viem";
+import { simulateContract, writeContract } from "viem/actions";
+
+// src/abi/legacyFeeClaims/ClankerSafeErc20Spender.ts
+var Clanker_v0_abi = [
+  {
+    type: "constructor",
+    inputs: [
+      { name: "owner_", type: "address", internalType: "address" },
+      { name: "teamSpender_", type: "address", internalType: "address" },
+      { name: "teamGrantedTokens_", type: "address[]", internalType: "address[]" }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "initializeTokenCreator",
+    inputs: [
+      { name: "token", type: "address", internalType: "address" },
+      { name: "newCreator", type: "address", internalType: "address" },
+      { name: "proof", type: "bytes32[]", internalType: "bytes32[]" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "owner",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "renounceOwnership",
+    inputs: [],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setTeamSpender",
+    inputs: [{ name: "teamSpender_", type: "address", internalType: "address" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setTokenCreatorRoot",
+    inputs: [{ name: "tokenCreatorRoot_", type: "bytes32", internalType: "bytes32" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "teamGrantedTokens",
+    inputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "teamGrantedTokensMap",
+    inputs: [{ name: "token", type: "address", internalType: "address" }],
+    outputs: [{ name: "teamGranted", type: "bool", internalType: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "teamSpender",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "teamTransfer",
+    inputs: [
+      { name: "safe", type: "address", internalType: "address" },
+      { name: "token", type: "address", internalType: "address" },
+      { name: "recipient", type: "address", internalType: "address" },
+      { name: "amount", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "teamTransferEth",
+    inputs: [{ name: "safe", type: "address", internalType: "address" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "tokenCreator",
+    inputs: [{ name: "token", type: "address", internalType: "address" }],
+    outputs: [{ name: "creator", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "tokenCreatorRoot",
+    inputs: [],
+    outputs: [{ name: "", type: "bytes32", internalType: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "tokenCreatorTransfer",
+    inputs: [
+      { name: "safe", type: "address", internalType: "address" },
+      { name: "token", type: "address", internalType: "address" },
+      { name: "recipient", type: "address", internalType: "address" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "transferOwnership",
+    inputs: [{ name: "newOwner", type: "address", internalType: "address" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "updateTokenCreator",
+    inputs: [
+      { name: "token", type: "address", internalType: "address" },
+      { name: "newCreator", type: "address", internalType: "address" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "event",
+    name: "InitializeTokenCreator",
+    inputs: [
+      { name: "token", type: "address", indexed: false, internalType: "address" },
+      { name: "initializer", type: "address", indexed: false, internalType: "address" },
+      { name: "creator", type: "address", indexed: false, internalType: "address" }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "OwnershipTransferred",
+    inputs: [
+      { name: "previousOwner", type: "address", indexed: true, internalType: "address" },
+      { name: "newOwner", type: "address", indexed: true, internalType: "address" }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "SetTeamSpender",
+    inputs: [
+      { name: "previousTeamSpender", type: "address", indexed: true, internalType: "address" },
+      { name: "newTeamSpender", type: "address", indexed: true, internalType: "address" }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "SetTokenCreatorRoot",
+    inputs: [
+      { name: "tokenCreatorRoot", type: "bytes32", indexed: false, internalType: "bytes32" }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Transfer",
+    inputs: [
+      { name: "safe", type: "address", indexed: true, internalType: "address" },
+      { name: "token", type: "address", indexed: true, internalType: "address" },
+      { name: "amount", type: "uint256", indexed: false, internalType: "uint256" },
+      { name: "spender", type: "address", indexed: false, internalType: "address" },
+      { name: "recipient", type: "address", indexed: true, internalType: "address" }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "UpdateTokenCreator",
+    inputs: [
+      { name: "token", type: "address", indexed: false, internalType: "address" },
+      { name: "previousCreator", type: "address", indexed: false, internalType: "address" },
+      { name: "newCreator", type: "address", indexed: false, internalType: "address" }
+    ],
+    anonymous: false
+  },
+  {
+    type: "error",
+    name: "InsufficientBalance",
+    inputs: [
+      { name: "safe", type: "address", internalType: "address" },
+      { name: "token", type: "address", internalType: "address" },
+      { name: "balance", type: "uint256", internalType: "uint256" }
+    ]
+  },
+  { type: "error", name: "InvalidProof", inputs: [] },
+  {
+    type: "error",
+    name: "NotAuthorizedToSpend",
+    inputs: [
+      { name: "sender", type: "address", internalType: "address" },
+      { name: "token", type: "address", internalType: "address" }
+    ]
+  },
+  {
+    type: "error",
+    name: "OwnableInvalidOwner",
+    inputs: [{ name: "owner", type: "address", internalType: "address" }]
+  },
+  {
+    type: "error",
+    name: "OwnableUnauthorizedAccount",
+    inputs: [{ name: "account", type: "address", internalType: "address" }]
+  },
+  {
+    type: "error",
+    name: "TokenCreatorAlreadyInitialized",
+    inputs: [
+      { name: "token", type: "address", internalType: "address" },
+      { name: "delegate", type: "address", internalType: "address" }
+    ]
+  },
+  {
+    type: "error",
+    name: "TokenCreatorRootAlreadySet",
+    inputs: [{ name: "tokenCreatorRoot", type: "bytes32", internalType: "bytes32" }]
+  },
+  { type: "error", name: "TokenCreatorRootNotSet", inputs: [] },
+  {
+    type: "error",
+    name: "Unauthorized",
+    inputs: [{ name: "unauthorized", type: "address", internalType: "address" }]
+  }
+];
+
+// src/utils/errors.ts
+import { BaseError, ContractFunctionRevertedError, InsufficientFundsError } from "viem";
+var ClankerError = class _ClankerError extends Error {
+  constructor(error, data) {
+    super(data.label);
+    this.error = error;
+    this.data = data;
+  }
+  static unknown(e, name) {
+    return new _ClankerError(e, {
+      type: "unknown",
+      label: "Something went wrong",
+      rawName: name || "unknown"
+    });
+  }
+};
+var SignatureToError = {
+  "0x7e5ba1ad": {
+    type: "state",
+    label: "Hook not enabled.",
+    rawName: "HookNotEnabled"
+  },
+  "0x8b063d73": {
+    type: "state",
+    label: "Too little received (likely dev buy).",
+    rawName: "V4TooLittleReceived"
+  }
+};
+var ErrorMapping = {
+  NoFeesToClaim: {
+    type: "state",
+    label: "No fees to claim",
+    rawName: "NoFeesToClaim"
+  },
+  InvalidVaultConfiguration: {
+    type: "caller",
+    label: "Invalid vault configuration",
+    rawName: "InvalidVault"
+  },
+  BaseFeeTooLow: {
+    type: "caller",
+    label: "Base fee is set too low",
+    rawName: "BaseFeeTooLow"
+  }
+};
+var understandError = (e) => {
+  if (!(e instanceof Error)) return ClankerError.unknown(new Error(`${e}`));
+  if (!(e instanceof BaseError)) return ClankerError.unknown(e);
+  const revertError = e.walk((e2) => e2 instanceof ContractFunctionRevertedError);
+  if (revertError instanceof ContractFunctionRevertedError) {
+    const errorName = revertError.data?.errorName ?? "";
+    const mapping = ErrorMapping[errorName];
+    if (mapping) return new ClankerError(e, mapping);
+    const signatureToError = SignatureToError[revertError.signature || "0x"];
+    if (signatureToError) return new ClankerError(e, signatureToError);
+    return ClankerError.unknown(e, errorName);
+  }
+  const fundsError = e.walk((e2) => e2 instanceof InsufficientFundsError);
+  if (fundsError instanceof InsufficientFundsError) {
+    return new ClankerError(fundsError, {
+      type: "caller",
+      label: "Insufficient funds.",
+      rawName: "InsufficientFundsError"
+    });
+  }
+  return ClankerError.unknown(e);
+};
+
+// src/legacyFeeClaims/index.ts
+var LEGACY_FEE_CLAIMS_ADDRESS = "0xe6D6cd9C493Ebf28C4b75d95B251eCA684D6b0de";
+var LegacyFeeClaims = class {
+  wallet;
+  publicClient;
+  constructor(config) {
+    this.wallet = config?.wallet;
+    this.publicClient = config?.publicClient;
+  }
+  /**
+   * Get an abi-typed transaction for initializing token creator ownership.
+   *
+   * This must be called once per token by the original creator to claim ownership
+   * of the token's fees. During this call, the creator can optionally set a different
+   * admin key to manage the token's rewards.
+   *
+   * @param token The token address to initialize a creator for
+   * @param newCreator The address to set as the creator for this token (can be different from msg.sender)
+   * @param proof The Merkle proof demonstrating msg.sender is authorized for this token
+   * @returns Abi transaction config
+   */
+  getInitializeTokenCreatorTransaction({
+    token,
+    newCreator,
+    proof
+  }) {
+    return {
+      address: LEGACY_FEE_CLAIMS_ADDRESS,
+      abi: Clanker_v0_abi,
+      functionName: "initializeTokenCreator",
+      args: [token, newCreator, proof]
+    };
+  }
+  /**
+   * Simulate initializing token creator ownership.
+   *
+   * @param token The token address to initialize a creator for
+   * @param newCreator The address to set as the creator for this token
+   * @param proof The Merkle proof demonstrating msg.sender is authorized for this token
+   * @param account Optional account to simulate calling for
+   * @returns The simulated output
+   */
+  async initializeTokenCreatorSimulate({
+    token,
+    newCreator,
+    proof
+  }, account) {
+    const acc = account || this.wallet?.account;
+    if (!acc) throw new Error("Account or wallet client required for simulation");
+    if (!this.publicClient) throw new Error("Public client required");
+    try {
+      return await simulateContract(this.publicClient, {
+        address: LEGACY_FEE_CLAIMS_ADDRESS,
+        abi: Clanker_v0_abi,
+        functionName: "initializeTokenCreator",
+        args: [token, newCreator, proof],
+        account: acc
+      });
+    } catch (e) {
+      return { error: understandError(e) };
+    }
+  }
+  /**
+   * Initialize token creator ownership to enable fee claims.
+   *
+   * This must be called once per token by the original creator. The proof must be
+   * obtained from the Clanker team or frontend. During initialization, you can
+   * optionally set a different admin address to manage future claims.
+   *
+   * @param token The token address to initialize a creator for
+   * @param newCreator The address to set as the creator for this token (can be different from msg.sender)
+   * @param proof The Merkle proof demonstrating msg.sender is authorized for this token
+   * @returns Transaction hash or error
+   */
+  async initializeTokenCreator({
+    token,
+    newCreator,
+    proof
+  }) {
+    if (!this.wallet) throw new Error("Wallet client required");
+    if (!this.publicClient) throw new Error("Public client required");
+    try {
+      const txHash = await writeContract(this.wallet, {
+        address: LEGACY_FEE_CLAIMS_ADDRESS,
+        abi: Clanker_v0_abi,
+        functionName: "initializeTokenCreator",
+        args: [token, newCreator, proof]
+      });
+      return { txHash, error: void 0 };
+    } catch (e) {
+      console.error(JSON.stringify(e, null, 2));
+      return { txHash: void 0, error: understandError(e) };
+    }
+  }
+  /**
+   * Get an abi-typed transaction for updating the token creator admin address.
+   *
+   * This allows the current creator to change the address that can trigger claims.
+   * Only callable by the current creator address for the specified token.
+   *
+   * @param token The token address to update the creator for
+   * @param newCreator The new creator/admin address
+   * @returns Abi transaction config
+   */
+  getUpdateTokenCreatorTransaction({
+    token,
+    newCreator
+  }) {
+    return {
+      address: LEGACY_FEE_CLAIMS_ADDRESS,
+      abi: Clanker_v0_abi,
+      functionName: "updateTokenCreator",
+      args: [token, newCreator]
+    };
+  }
+  /**
+   * Simulate updating the token creator admin address.
+   *
+   * @param token The token address to update the creator for
+   * @param newCreator The new creator/admin address
+   * @param account Optional account to simulate calling for
+   * @returns The simulated output
+   */
+  async updateTokenCreatorSimulate({
+    token,
+    newCreator
+  }, account) {
+    const acc = account || this.wallet?.account;
+    if (!acc) throw new Error("Account or wallet client required for simulation");
+    if (!this.publicClient) throw new Error("Public client required");
+    try {
+      return await simulateContract(this.publicClient, {
+        address: LEGACY_FEE_CLAIMS_ADDRESS,
+        abi: Clanker_v0_abi,
+        functionName: "updateTokenCreator",
+        args: [token, newCreator],
+        account: acc
+      });
+    } catch (e) {
+      return { error: understandError(e) };
+    }
+  }
+  /**
+   * Update the token creator admin address.
+   *
+   * This allows you to change which address can trigger fee claims for your token.
+   * Only callable by the current creator address.
+   *
+   * @param token The token address to update the creator for
+   * @param newCreator The new creator/admin address
+   * @returns Transaction hash or error
+   */
+  async updateTokenCreator({
+    token,
+    newCreator
+  }) {
+    if (!this.wallet) throw new Error("Wallet client required");
+    if (!this.publicClient) throw new Error("Public client required");
+    try {
+      const txHash = await writeContract(this.wallet, {
+        address: LEGACY_FEE_CLAIMS_ADDRESS,
+        abi: Clanker_v0_abi,
+        functionName: "updateTokenCreator",
+        args: [token, newCreator]
+      });
+      return { txHash, error: void 0 };
+    } catch (e) {
+      return { txHash: void 0, error: understandError(e) };
+    }
+  }
+  /**
+   * Get an abi-typed transaction for claiming token creator fees.
+   *
+   * This allows the authorized creator to transfer all accumulated fees from the
+   * Safe wallet to any recipient address. Only callable by the authorized creator
+   * for the specified token.
+   *
+   * @param safe The Safe wallet address holding the fees
+   * @param token The ERC20 token address to transfer
+   * @param recipient The address to receive the fees
+   * @returns Abi transaction config
+   */
+  getTokenCreatorTransferTransaction({
+    safe,
+    token,
+    recipient
+  }) {
+    return {
+      address: LEGACY_FEE_CLAIMS_ADDRESS,
+      abi: Clanker_v0_abi,
+      functionName: "tokenCreatorTransfer",
+      args: [safe, token, recipient]
+    };
+  }
+  /**
+   * Simulate claiming token creator fees.
+   *
+   * @param safe The Safe wallet address holding the fees
+   * @param token The ERC20 token address to transfer
+   * @param recipient The address to receive the fees
+   * @param account Optional account to simulate calling for
+   * @returns The simulated output
+   */
+  async tokenCreatorTransferSimulate({
+    safe,
+    token,
+    recipient
+  }, account) {
+    const acc = account || this.wallet?.account;
+    if (!acc) throw new Error("Account or wallet client required for simulation");
+    if (!this.publicClient) throw new Error("Public client required");
+    try {
+      return await simulateContract(this.publicClient, {
+        address: LEGACY_FEE_CLAIMS_ADDRESS,
+        abi: Clanker_v0_abi,
+        functionName: "tokenCreatorTransfer",
+        args: [safe, token, recipient],
+        account: acc
+      });
+    } catch (e) {
+      return { error: understandError(e) };
+    }
+  }
+  /**
+   * Claim token creator fees by transferring them from the Safe to a recipient.
+   *
+   * This transfers all accumulated fees for your token to the specified recipient.
+   * Only callable by the authorized creator address for the token.
+   *
+   * Note: Not all Clanker tokens can be sent to the zero address. If you get an error,
+   * consider sending to 0x000000000000000000000000000000000000dEaD instead.
+   *
+   * @param safe The Safe wallet address holding the fees
+   * @param token The ERC20 token address to transfer
+   * @param recipient The address to receive the fees
+   * @returns Transaction hash or error
+   */
+  async tokenCreatorTransfer({
+    safe,
+    token,
+    recipient
+  }) {
+    if (!this.wallet) throw new Error("Wallet client required");
+    if (!this.publicClient) throw new Error("Public client required");
+    try {
+      const txHash = await writeContract(this.wallet, {
+        address: LEGACY_FEE_CLAIMS_ADDRESS,
+        abi: Clanker_v0_abi,
+        functionName: "tokenCreatorTransfer",
+        args: [safe, token, recipient]
+      });
+      return { txHash, error: void 0 };
+    } catch (e) {
+      return { txHash: void 0, error: understandError(e) };
+    }
+  }
+  /**
+   * Get the stored creator address for a token.
+   *
+   * Returns the address that is authorized to claim fees for this token.
+   * Returns zero address if the token creator has not been initialized yet.
+   *
+   * @param token The token address to check
+   * @returns The creator address for the token
+   */
+  async getTokenCreator({ token }) {
+    if (!this.publicClient) throw new Error("Public client required");
+    return this.publicClient.readContract({
+      address: LEGACY_FEE_CLAIMS_ADDRESS,
+      abi: Clanker_v0_abi,
+      functionName: "tokenCreator",
+      args: [token]
+    });
+  }
+  /**
+   * Get the current Merkle root used for verifying token creator proofs.
+   *
+   * This is used internally by the contract to verify initialization proofs.
+   *
+   * @returns The current token creator Merkle root
+   */
+  async getTokenCreatorRoot() {
+    if (!this.publicClient) throw new Error("Public client required");
+    return this.publicClient.readContract({
+      address: LEGACY_FEE_CLAIMS_ADDRESS,
+      abi: Clanker_v0_abi,
+      functionName: "tokenCreatorRoot",
+      args: []
+    });
+  }
+};
+function generateLeafHash(tokenAddress, currentCreator) {
+  const packed = `0x${tokenAddress.slice(2)}${currentCreator.slice(2)}`;
+  return keccak256(packed);
+}
+function getTokenCreatorMerkleProof(entries, targetToken) {
+  const normalizedTarget = targetToken.toLowerCase();
+  const targetIndex = entries.findIndex((e) => e.tokenAddress.toLowerCase() === normalizedTarget);
+  if (targetIndex === -1) {
+    return null;
+  }
+  const targetEntry = entries[targetIndex];
+  const values = entries.map((e) => [e.tokenAddress, e.currentCreator]);
+  const tree = StandardMerkleTree.of(values, ["address", "address"]);
+  const proof = tree.getProof(targetIndex);
+  const leafHash = generateLeafHash(targetEntry.tokenAddress, targetEntry.currentCreator);
+  return {
+    tokenAddress: targetEntry.tokenAddress,
+    currentCreator: targetEntry.currentCreator,
+    proof,
+    leafHash,
+    root: tree.root,
+    index: targetIndex
+  };
+}
+function parseTokenCreatorCSV(csvContent) {
+  const lines = csvContent.trim().split("\n");
+  const dataLines = lines.slice(1);
+  return dataLines.map((line) => {
+    const [tokenAddress, currentCreator] = line.split(",").map((s) => s.trim());
+    return {
+      tokenAddress,
+      currentCreator
+    };
+  });
+}
+var EXPECTED_MERKLE_ROOT = "0xa7dcc91a2136ef1b3c708dbab901cbeb075f6df5cf5987494fedc340c57f7025";
+function getInitializeTokenCreatorTransaction({
+  token,
+  newCreator,
+  proof
+}) {
+  return {
+    address: LEGACY_FEE_CLAIMS_ADDRESS,
+    abi: Clanker_v0_abi,
+    functionName: "initializeTokenCreator",
+    args: [token, newCreator, proof]
+  };
+}
+function getUpdateTokenCreatorTransaction({
+  token,
+  newCreator
+}) {
+  return {
+    address: LEGACY_FEE_CLAIMS_ADDRESS,
+    abi: Clanker_v0_abi,
+    functionName: "updateTokenCreator",
+    args: [token, newCreator]
+  };
+}
+function getTokenCreatorTransferTransaction({
+  safe,
+  token,
+  recipient
+}) {
+  return {
+    address: LEGACY_FEE_CLAIMS_ADDRESS,
+    abi: Clanker_v0_abi,
+    functionName: "tokenCreatorTransfer",
+    args: [safe, token, recipient]
+  };
+}
+export {
+  EXPECTED_MERKLE_ROOT,
+  LEGACY_FEE_CLAIMS_ADDRESS,
+  LegacyFeeClaims,
+  generateLeafHash,
+  getInitializeTokenCreatorTransaction,
+  getTokenCreatorMerkleProof,
+  getTokenCreatorTransferTransaction,
+  getUpdateTokenCreatorTransaction,
+  parseTokenCreatorCSV
+};

package/dist/v3/index.d.ts

@@ -1,8 +1,9 @@
-import { C as ClankerTransactionConfig, a as Clanker_v3_1_abi, b as ClankerError, c as ClankerFactory, d as ClankerResult } from '../write-clanker-contracts-DVM3LXMa.js';
+import { C as ClankerTransactionConfig, a as Clanker_v3_1_abi, b as ClankerFactory, c as ClankerResult } from '../write-clanker-contracts-B4LSHPv2.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';
 import { C as ClankerTokenV3 } from '../clankerTokenV3-BqHTF9QY.js';
+import { C as ClankerError } from '../errors-5Gv28Tkr.js';
 import 'zod/v4';
 
 type ClankerConfig = {

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

@@ -1,8 +1,9 @@
-import { C as ClankerTransactionConfig, g as ClankerAirdrop_v4_abi, d as ClankerResult, h as Clanker_PresaleEthToCreator_v4_1_abi, b as ClankerError } from '../../write-clanker-contracts-DVM3LXMa.js';
+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 { MerkleTree } from '@openzeppelin/merkle-tree/dist/merkletree.js';
 import * as z from 'zod/v4';
-import { a as Chain, C as ClankerTokenV4 } from '../../clankerTokenV4-CYKWWpwe.js';
+import { a as Chain, C as ClankerTokenV4 } from '../../clankerTokenV4-Btn0ZN4v.js';
 import { Clanker } from '../index.js';
+import { C as ClankerError } from '../../errors-5Gv28Tkr.js';
 import 'viem';
 import '../../ClankerToken-Dra5lppJ.js';