clanker-sdk 3.9.5 → 3.9.8

package/dist/cli/cli.js

@@ -0,0 +1,1353 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/constants.ts
+var WETH_ADDRESS, CLANKER_FACTORY_V3_1;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    "use strict";
+    init_esm_shims();
+    WETH_ADDRESS = "0x4200000000000000000000000000000000000006";
+    CLANKER_FACTORY_V3_1 = "0x2A787b2362021cC3eEa3C24C4748a6cD5B687382";
+  }
+});
+
+// src/abis/Clanker_V3_1.ts
+var Clanker_v3_1_abi;
+var init_Clanker_V3_1 = __esm({
+  "src/abis/Clanker_V3_1.ts"() {
+    "use strict";
+    init_esm_shims();
+    Clanker_v3_1_abi = [
+      {
+        inputs: [{ internalType: "address", name: "owner_", type: "address" }],
+        stateMutability: "nonpayable",
+        type: "constructor"
+      },
+      { inputs: [], name: "Deprecated", type: "error" },
+      { inputs: [], name: "InvalidCreatorInfo", type: "error" },
+      { inputs: [], name: "InvalidCreatorReward", type: "error" },
+      { inputs: [], name: "InvalidInterfaceInfo", type: "error" },
+      { inputs: [], name: "InvalidTick", type: "error" },
+      { inputs: [], name: "InvalidVaultConfiguration", type: "error" },
+      { inputs: [], name: "NotFound", type: "error" },
+      { inputs: [], name: "OnlyNonOriginatingChains", type: "error" },
+      { inputs: [], name: "OnlyOriginatingChain", type: "error" },
+      {
+        inputs: [{ internalType: "address", name: "owner", type: "address" }],
+        name: "OwnableInvalidOwner",
+        type: "error"
+      },
+      {
+        inputs: [{ internalType: "address", name: "account", type: "address" }],
+        name: "OwnableUnauthorizedAccount",
+        type: "error"
+      },
+      { inputs: [], name: "ReentrancyGuardReentrantCall", type: "error" },
+      { inputs: [], name: "Unauthorized", type: "error" },
+      { inputs: [], name: "ZeroTeamRewardRecipient", type: "error" },
+      {
+        anonymous: false,
+        inputs: [
+          { indexed: false, internalType: "address", name: "oldClankerDeployer", type: "address" },
+          { indexed: false, internalType: "address", name: "newClankerDeployer", type: "address" }
+        ],
+        name: "ClankerDeployerUpdated",
+        type: "event"
+      },
+      {
+        anonymous: false,
+        inputs: [
+          { indexed: false, internalType: "address", name: "oldLocker", type: "address" },
+          { indexed: false, internalType: "address", name: "newLocker", type: "address" }
+        ],
+        name: "LiquidityLockerUpdated",
+        type: "event"
+      },
+      {
+        anonymous: false,
+        inputs: [
+          { indexed: true, internalType: "address", name: "previousOwner", type: "address" },
+          { indexed: true, internalType: "address", name: "newOwner", type: "address" }
+        ],
+        name: "OwnershipTransferred",
+        type: "event"
+      },
+      {
+        anonymous: false,
+        inputs: [
+          { indexed: false, internalType: "address", name: "admin", type: "address" },
+          { indexed: false, internalType: "bool", name: "isAdmin", type: "bool" }
+        ],
+        name: "SetAdmin",
+        type: "event"
+      },
+      {
+        anonymous: false,
+        inputs: [{ indexed: false, internalType: "bool", name: "deprecated", type: "bool" }],
+        name: "SetDeprecated",
+        type: "event"
+      },
+      {
+        anonymous: false,
+        inputs: [
+          { indexed: true, internalType: "address", name: "tokenAddress", type: "address" },
+          { indexed: true, internalType: "address", name: "creatorAdmin", type: "address" },
+          { indexed: true, internalType: "address", name: "interfaceAdmin", type: "address" },
+          { indexed: false, internalType: "address", name: "creatorRewardRecipient", type: "address" },
+          {
+            indexed: false,
+            internalType: "address",
+            name: "interfaceRewardRecipient",
+            type: "address"
+          },
+          { indexed: false, internalType: "uint256", name: "positionId", type: "uint256" },
+          { indexed: false, internalType: "string", name: "name", type: "string" },
+          { indexed: false, internalType: "string", name: "symbol", type: "string" },
+          {
+            indexed: false,
+            internalType: "int24",
+            name: "startingTickIfToken0IsNewToken",
+            type: "int24"
+          },
+          { indexed: false, internalType: "string", name: "metadata", type: "string" },
+          { indexed: false, internalType: "uint256", name: "amountTokensBought", type: "uint256" },
+          { indexed: false, internalType: "uint256", name: "vaultDuration", type: "uint256" },
+          { indexed: false, internalType: "uint8", name: "vaultPercentage", type: "uint8" },
+          { indexed: false, internalType: "address", name: "msgSender", type: "address" }
+        ],
+        name: "TokenCreated",
+        type: "event"
+      },
+      {
+        anonymous: false,
+        inputs: [
+          { indexed: false, internalType: "address", name: "oldVault", type: "address" },
+          { indexed: false, internalType: "address", name: "newVault", type: "address" }
+        ],
+        name: "VaultUpdated",
+        type: "event"
+      },
+      {
+        inputs: [],
+        name: "MAX_CREATOR_REWARD",
+        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function"
+      },
+      {
+        inputs: [],
+        name: "MAX_TICK",
+        outputs: [{ internalType: "int24", name: "", type: "int24" }],
+        stateMutability: "view",
+        type: "function"
+      },
+      {
+        inputs: [],
+        name: "MAX_VAULT_PERCENTAGE",
+        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function"
+      },
+      {
+        inputs: [],
+        name: "POOL_FEE",
+        outputs: [{ internalType: "uint24", name: "", type: "uint24" }],
+        stateMutability: "view",
+        type: "function"
+      },
+      {
+        inputs: [],
+        name: "TICK_SPACING",
+        outputs: [{ internalType: "int24", name: "", type: "int24" }],
+        stateMutability: "view",
+        type: "function"
+      },
+      {
+        inputs: [],
+        name: "TOKEN_SUPPLY",
+        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function"
+      },
+      {
+        inputs: [{ internalType: "address", name: "", type: "address" }],
+        name: "admins",
+        outputs: [{ internalType: "bool", name: "", type: "bool" }],
+        stateMutability: "view",
+        type: "function"
+      },
+      {
+        inputs: [{ internalType: "address", name: "token", type: "address" }],
+        name: "claimRewards",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function"
+      },
+      {
+        inputs: [
+          {
+            components: [
+              {
+                components: [
+                  { internalType: "string", name: "name", type: "string" },
+                  { internalType: "string", name: "symbol", type: "string" },
+                  { internalType: "bytes32", name: "salt", type: "bytes32" },
+                  { internalType: "string", name: "image", type: "string" },
+                  { internalType: "string", name: "metadata", type: "string" },
+                  { internalType: "string", name: "context", type: "string" },
+                  { internalType: "uint256", name: "originatingChainId", type: "uint256" }
+                ],
+                internalType: "struct IClanker.TokenConfig",
+                name: "tokenConfig",
+                type: "tuple"
+              },
+              {
+                components: [
+                  { internalType: "uint8", name: "vaultPercentage", type: "uint8" },
+                  { internalType: "uint256", name: "vaultDuration", type: "uint256" }
+                ],
+                internalType: "struct IClanker.VaultConfig",
+                name: "vaultConfig",
+                type: "tuple"
+              },
+              {
+                components: [
+                  { internalType: "address", name: "pairedToken", type: "address" },
+                  { internalType: "int24", name: "tickIfToken0IsNewToken", type: "int24" }
+                ],
+                internalType: "struct IClanker.PoolConfig",
+                name: "poolConfig",
+                type: "tuple"
+              },
+              {
+                components: [
+                  { internalType: "uint24", name: "pairedTokenPoolFee", type: "uint24" },
+                  { internalType: "uint256", name: "pairedTokenSwapAmountOutMinimum", type: "uint256" }
+                ],
+                internalType: "struct IClanker.InitialBuyConfig",
+                name: "initialBuyConfig",
+                type: "tuple"
+              },
+              {
+                components: [
+                  { internalType: "uint256", name: "creatorReward", type: "uint256" },
+                  { internalType: "address", name: "creatorAdmin", type: "address" },
+                  { internalType: "address", name: "creatorRewardRecipient", type: "address" },
+                  { internalType: "address", name: "interfaceAdmin", type: "address" },
+                  { internalType: "address", name: "interfaceRewardRecipient", type: "address" }
+                ],
+                internalType: "struct IClanker.RewardsConfig",
+                name: "rewardsConfig",
+                type: "tuple"
+              }
+            ],
+            internalType: "struct IClanker.DeploymentConfig",
+            name: "deploymentConfig",
+            type: "tuple"
+          }
+        ],
+        name: "deployToken",
+        outputs: [
+          { internalType: "address", name: "tokenAddress", type: "address" },
+          { internalType: "uint256", name: "positionId", type: "uint256" }
+        ],
+        stateMutability: "payable",
+        type: "function"
+      },
+      {
+        inputs: [
+          {
+            components: [
+              {
+                components: [
+                  { internalType: "string", name: "name", type: "string" },
+                  { internalType: "string", name: "symbol", type: "string" },
+                  { internalType: "bytes32", name: "salt", type: "bytes32" },
+                  { internalType: "string", name: "image", type: "string" },
+                  { internalType: "string", name: "metadata", type: "string" },
+                  { internalType: "string", name: "context", type: "string" },
+                  { internalType: "uint256", name: "originatingChainId", type: "uint256" }
+                ],
+                internalType: "struct IClanker.TokenConfig",
+                name: "tokenConfig",
+                type: "tuple"
+              },
+              {
+                components: [
+                  { internalType: "uint8", name: "vaultPercentage", type: "uint8" },
+                  { internalType: "uint256", name: "vaultDuration", type: "uint256" }
+                ],
+                internalType: "struct IClanker.VaultConfig",
+                name: "vaultConfig",
+                type: "tuple"
+              },
+              {
+                components: [
+                  { internalType: "address", name: "pairedToken", type: "address" },
+                  { internalType: "int24", name: "tickIfToken0IsNewToken", type: "int24" }
+                ],
+                internalType: "struct IClanker.PoolConfig",
+                name: "poolConfig",
+                type: "tuple"
+              },
+              {
+                components: [
+                  { internalType: "uint24", name: "pairedTokenPoolFee", type: "uint24" },
+                  { internalType: "uint256", name: "pairedTokenSwapAmountOutMinimum", type: "uint256" }
+                ],
+                internalType: "struct IClanker.InitialBuyConfig",
+                name: "initialBuyConfig",
+                type: "tuple"
+              },
+              {
+                components: [
+                  { internalType: "uint256", name: "creatorReward", type: "uint256" },
+                  { internalType: "address", name: "creatorAdmin", type: "address" },
+                  { internalType: "address", name: "creatorRewardRecipient", type: "address" },
+                  { internalType: "address", name: "interfaceAdmin", type: "address" },
+                  { internalType: "address", name: "interfaceRewardRecipient", type: "address" }
+                ],
+                internalType: "struct IClanker.RewardsConfig",
+                name: "rewardsConfig",
+                type: "tuple"
+              }
+            ],
+            internalType: "struct IClanker.DeploymentConfig",
+            name: "deploymentConfig",
+            type: "tuple"
+          },
+          { internalType: "address", name: "teamRewardRecipient", type: "address" }
+        ],
+        name: "deployTokenWithCustomTeamRewardRecipient",
+        outputs: [
+          { internalType: "address", name: "tokenAddress", type: "address" },
+          { internalType: "uint256", name: "positionId", type: "uint256" }
+        ],
+        stateMutability: "payable",
+        type: "function"
+      },
+      {
+        inputs: [
+          {
+            components: [
+              { internalType: "string", name: "name", type: "string" },
+              { internalType: "string", name: "symbol", type: "string" },
+              { internalType: "bytes32", name: "salt", type: "bytes32" },
+              { internalType: "string", name: "image", type: "string" },
+              { internalType: "string", name: "metadata", type: "string" },
+              { internalType: "string", name: "context", type: "string" },
+              { internalType: "uint256", name: "originatingChainId", type: "uint256" }
+            ],
+            internalType: "struct IClanker.TokenConfig",
+            name: "tokenConfig",
+            type: "tuple"
+          },
+          { internalType: "address", name: "tokenAdmin", type: "address" }
+        ],
+        name: "deployTokenZeroSupply",
+        outputs: [{ internalType: "address", name: "tokenAddress", type: "address" }],
+        stateMutability: "nonpayable",
+        type: "function"
+      },
+      {
+        inputs: [{ internalType: "address", name: "", type: "address" }],
+        name: "deploymentInfoForToken",
+        outputs: [
+          { internalType: "address", name: "token", type: "address" },
+          { internalType: "uint256", name: "positionId", type: "uint256" },
+          { internalType: "address", name: "locker", type: "address" }
+        ],
+        stateMutability: "view",
+        type: "function"
+      },
+      {
+        inputs: [],
+        name: "deprecated",
+        outputs: [{ internalType: "bool", name: "", type: "bool" }],
+        stateMutability: "view",
+        type: "function"
+      },
+      {
+        inputs: [{ internalType: "address", name: "user", type: "address" }],
+        name: "getTokensDeployedByUser",
+        outputs: [
+          {
+            components: [
+              { internalType: "address", name: "token", type: "address" },
+              { internalType: "uint256", name: "positionId", type: "uint256" },
+              { internalType: "address", name: "locker", type: "address" }
+            ],
+            internalType: "struct IClanker.DeploymentInfo[]",
+            name: "",
+            type: "tuple[]"
+          }
+        ],
+        stateMutability: "view",
+        type: "function"
+      },
+      {
+        inputs: [
+          { internalType: "address", name: "uniswapV3Factory_", type: "address" },
+          { internalType: "address", name: "positionManager_", type: "address" },
+          { internalType: "address", name: "swapRouter_", type: "address" },
+          { internalType: "address", name: "weth_", type: "address" },
+          { internalType: "address", name: "liquidityLocker_", type: "address" },
+          { internalType: "address", name: "vault_", type: "address" }
+        ],
+        name: "initialize",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function"
+      },
+      {
+        inputs: [],
+        name: "liquidityLocker",
+        outputs: [{ internalType: "contract ILpLockerv2", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function"
+      },
+      {
+        inputs: [],
+        name: "owner",
+        outputs: [{ internalType: "address", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function"
+      },
+      {
+        inputs: [],
+        name: "positionManager",
+        outputs: [{ internalType: "contract INonfungiblePositionManager", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function"
+      },
+      {
+        inputs: [],
+        name: "renounceOwnership",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function"
+      },
+      {
+        inputs: [
+          { internalType: "address", name: "admin", type: "address" },
+          { internalType: "bool", name: "isAdmin", type: "bool" }
+        ],
+        name: "setAdmin",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function"
+      },
+      {
+        inputs: [{ internalType: "bool", name: "deprecated_", type: "bool" }],
+        name: "setDeprecated",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function"
+      },
+      {
+        inputs: [],
+        name: "swapRouter",
+        outputs: [{ internalType: "contract ISwapRouter", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function"
+      },
+      {
+        inputs: [
+          { internalType: "address", name: "", type: "address" },
+          { internalType: "uint256", name: "", type: "uint256" }
+        ],
+        name: "tokensDeployedByUsers",
+        outputs: [
+          { internalType: "address", name: "token", type: "address" },
+          { internalType: "uint256", name: "positionId", type: "uint256" },
+          { internalType: "address", name: "locker", type: "address" }
+        ],
+        stateMutability: "view",
+        type: "function"
+      },
+      {
+        inputs: [{ internalType: "address", name: "newOwner", type: "address" }],
+        name: "transferOwnership",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function"
+      },
+      {
+        inputs: [],
+        name: "uniswapV3Factory",
+        outputs: [{ internalType: "contract IUniswapV3Factory", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function"
+      },
+      {
+        inputs: [{ internalType: "address", name: "newLocker", type: "address" }],
+        name: "updateLiquidityLocker",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function"
+      },
+      {
+        inputs: [{ internalType: "address", name: "newVault", type: "address" }],
+        name: "updateVault",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function"
+      },
+      {
+        inputs: [],
+        name: "vault",
+        outputs: [{ internalType: "contract IClankerVault", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function"
+      },
+      {
+        inputs: [],
+        name: "weth",
+        outputs: [{ internalType: "address", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function"
+      }
+    ];
+  }
+});
+
+// src/types.ts
+var init_types = __esm({
+  "src/types.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/index.ts
+import {
+  parseEther,
+  parseUnits,
+  stringify,
+  parseEventLogs,
+  encodeFunctionData
+} from "viem";
+import { simulateContract, writeContract, readContract } from "viem/actions";
+var ERC20_DECIMALS_ABI, UNIV3_FACTORY_ABI, UNIV3_POOL_ABI, UNIV3_FACTORY, FEE_TIERS, Clanker;
+var init_index = __esm({
+  "src/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    init_Clanker_V3_1();
+    init_types();
+    ERC20_DECIMALS_ABI = [
+      {
+        inputs: [],
+        name: "decimals",
+        outputs: [{ type: "uint8", name: "" }],
+        stateMutability: "view",
+        type: "function"
+      }
+    ];
+    UNIV3_FACTORY_ABI = [
+      {
+        inputs: [
+          { internalType: "address", name: "tokenA", type: "address" },
+          { internalType: "address", name: "tokenB", type: "address" },
+          { internalType: "uint24", name: "fee", type: "uint24" }
+        ],
+        name: "getPool",
+        outputs: [{ internalType: "address", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function"
+      }
+    ];
+    UNIV3_POOL_ABI = [
+      {
+        inputs: [],
+        name: "liquidity",
+        outputs: [{ internalType: "uint128", name: "", type: "uint128" }],
+        stateMutability: "view",
+        type: "function"
+      },
+      {
+        inputs: [],
+        name: "slot0",
+        outputs: [
+          { internalType: "uint160", name: "sqrtPriceX96", type: "uint160" },
+          { internalType: "int24", name: "tick", type: "int24" },
+          { internalType: "uint16", name: "observationIndex", type: "uint16" },
+          { internalType: "uint16", name: "observationCardinality", type: "uint16" },
+          { internalType: "uint16", name: "observationCardinalityNext", type: "uint16" },
+          { internalType: "uint8", name: "feeProtocol", type: "uint8" },
+          { internalType: "bool", name: "unlocked", type: "bool" }
+        ],
+        stateMutability: "view",
+        type: "function"
+      }
+    ];
+    UNIV3_FACTORY = "0x33128a8fC17869897dcE68Ed026d694621f6FDfD";
+    FEE_TIERS = [100, 500, 3e3, 1e4];
+    Clanker = class {
+      wallet;
+      factoryAddress;
+      publicClient;
+      constructor(config2) {
+        this.wallet = config2.wallet;
+        this.publicClient = config2.publicClient;
+        this.factoryAddress = config2.factoryAddress ?? CLANKER_FACTORY_V3_1;
+      }
+      // Get quote token decimals
+      async getQuoteTokenDecimals(quoteToken) {
+        try {
+          const decimals = await readContract(this.publicClient, {
+            address: quoteToken,
+            abi: ERC20_DECIMALS_ABI,
+            functionName: "decimals"
+          });
+          return decimals;
+        } catch (error) {
+          console.warn(`Failed to fetch decimals for quote token ${quoteToken}, defaulting to 18:`, error);
+          return 18;
+        }
+      }
+      // Find the most liquid pool between WETH and quote token
+      async findMostLiquidPool(quoteToken) {
+        const pools = await Promise.all(
+          FEE_TIERS.map(async (fee) => {
+            try {
+              const poolAddress = await readContract(this.publicClient, {
+                address: UNIV3_FACTORY,
+                abi: UNIV3_FACTORY_ABI,
+                functionName: "getPool",
+                args: [WETH_ADDRESS, quoteToken, fee]
+              });
+              if (poolAddress === "0x0000000000000000000000000000000000000000") {
+                return { fee, liquidity: 0n, sqrtPriceX96: 0n };
+              }
+              const [liquidity, slot0] = await Promise.all([
+                readContract(this.publicClient, {
+                  address: poolAddress,
+                  abi: UNIV3_POOL_ABI,
+                  functionName: "liquidity"
+                }),
+                readContract(this.publicClient, {
+                  address: poolAddress,
+                  abi: UNIV3_POOL_ABI,
+                  functionName: "slot0"
+                })
+              ]);
+              return { fee, liquidity, sqrtPriceX96: slot0[0] };
+            } catch (error) {
+              console.warn(`Failed to get pool info for fee tier ${fee}:`, error);
+              return { fee, liquidity: 0n, sqrtPriceX96: 0n };
+            }
+          })
+        );
+        const mostLiquidPool = pools.reduce(
+          (max, current) => current.liquidity > max.liquidity ? current : max
+        );
+        if (mostLiquidPool.liquidity === 0n) {
+          console.warn("No liquid pool found, defaulting to 1% fee tier");
+          return { fee: 1e4, sqrtPriceX96: 0n };
+        }
+        return { fee: mostLiquidPool.fee, sqrtPriceX96: mostLiquidPool.sqrtPriceX96 };
+      }
+      // Calculate minimum output amount for WETH -> quote token swap
+      calculateMinimumOutput(ethAmount, sqrtPriceX96, quoteDecimals, slippagePercent) {
+        if (sqrtPriceX96 === 0n) {
+          return 0n;
+        }
+        const Q96 = BigInt("79228162514264337593543950336");
+        const price = (Number(sqrtPriceX96) / Number(Q96)) ** 2;
+        const ethDecimals = 18;
+        const ethAmountInEth = Number(ethAmount) / 10 ** ethDecimals;
+        const expectedOutput = ethAmountInEth * price;
+        const minimumOutput = expectedOutput * (1 - slippagePercent / 100);
+        return BigInt(Math.floor(minimumOutput * 10 ** quoteDecimals));
+      }
+      // Calculate tick based on quote token and token ordering
+      async calculateTickForQuoteToken(quoteToken, marketCap) {
+        const quoteDecimals = await this.getQuoteTokenDecimals(quoteToken);
+        console.log("Quote token decimals:", quoteDecimals);
+        const tokenDecimals = 18;
+        const totalSupply = BigInt(1e11) * BigInt(10) ** BigInt(tokenDecimals);
+        const priceInQuoteToken = Number(marketCap) / Number(totalSupply);
+        console.log("Price in quote token:", priceInQuoteToken);
+        console.log("Market cap in quote token units:", Number(marketCap) / 10 ** quoteDecimals);
+        const logBase = 1.0001;
+        const tickSpacing = 200;
+        const dummyTokenAddress = "0xffffffffffffffffffffffffffffffffffffffff";
+        const isToken0 = dummyTokenAddress.toLowerCase() < quoteToken.toLowerCase();
+        console.log("Is new token token0?", isToken0);
+        const priceForTick = isToken0 ? priceInQuoteToken : 1 / priceInQuoteToken;
+        let rawTick = Math.floor(Math.log(priceForTick) / Math.log(logBase));
+        if (!isToken0) {
+          rawTick = -rawTick;
+        }
+        console.log("Raw tick (before spacing):", rawTick);
+        const initialTick = Math.floor(rawTick / tickSpacing) * tickSpacing;
+        console.log("Final tick (rounded to spacing):", initialTick);
+        const actualPrice = Math.pow(logBase, isToken0 ? initialTick : -initialTick);
+        console.log("Actual price from tick:", actualPrice);
+        const finalPrice = isToken0 ? actualPrice : 1 / actualPrice;
+        const actualMarketCap = finalPrice * Number(totalSupply) / Math.pow(10, tokenDecimals);
+        console.log("Actual market cap in quote token:", actualMarketCap);
+        return initialTick;
+      }
+      handleError(error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Deployment failed: ${message}`);
+      }
+      async deploy(config2) {
+        if (!this.wallet?.account) {
+          throw new Error("Wallet account not configured");
+        }
+        try {
+          const rewardsConfig = config2.rewardsConfig;
+          const tick = await this.calculateTickForQuoteToken(
+            config2.poolConfig.pairedToken,
+            config2.poolConfig.initialMarketCapInPairedToken
+          );
+          const deploymentData = {
+            tokenConfig: {
+              name: config2.tokenConfig.name,
+              symbol: config2.tokenConfig.symbol,
+              salt: config2.tokenConfig.salt,
+              image: config2.tokenConfig.image,
+              metadata: stringify(config2.tokenConfig.metadata),
+              context: stringify(config2.tokenConfig.context),
+              originatingChainId: config2.tokenConfig.originatingChainId
+            },
+            vaultConfig: {
+              vaultPercentage: config2.vaultConfig?.vaultPercentage ?? 0,
+              vaultDuration: config2.vaultConfig?.vaultDuration ?? BigInt(0)
+            },
+            poolConfig: {
+              pairedToken: config2.poolConfig.pairedToken,
+              tickIfToken0IsNewToken: tick
+            },
+            initialBuyConfig: {
+              pairedTokenPoolFee: config2.initialBuyConfig?.pairedTokenPoolFee ?? 1e4,
+              pairedTokenSwapAmountOutMinimum: config2.initialBuyConfig?.pairedTokenSwapAmountOutMinimum ?? BigInt(0)
+            },
+            rewardsConfig: {
+              creatorReward: rewardsConfig.creatorReward,
+              creatorAdmin: rewardsConfig.creatorAdmin,
+              creatorRewardRecipient: rewardsConfig.creatorRewardRecipient,
+              interfaceAdmin: rewardsConfig.interfaceAdmin,
+              interfaceRewardRecipient: rewardsConfig.interfaceRewardRecipient
+            }
+          };
+          const { request } = await simulateContract(this.publicClient, {
+            address: this.factoryAddress,
+            abi: Clanker_v3_1_abi,
+            functionName: "deployToken",
+            args: [deploymentData],
+            value: config2.initialBuyConfig?.ethAmount ?? BigInt(0),
+            chain: this.publicClient.chain,
+            account: this.wallet.account
+          });
+          const hash = await writeContract(this.wallet, request);
+          const receipt = await this.publicClient.waitForTransactionReceipt({
+            hash
+          });
+          const [log] = parseEventLogs({
+            abi: Clanker_v3_1_abi,
+            eventName: "TokenCreated",
+            logs: receipt.logs
+          });
+          if (!log) {
+            throw new Error("No deployment event found");
+          }
+          return log.args.tokenAddress;
+        } catch (error) {
+          this.handleError(error);
+        }
+      }
+      async buildDeploymentConfig(cfg) {
+        const quoteToken = cfg.pool?.quoteToken ?? WETH_ADDRESS;
+        const quoteDecimals = await this.getQuoteTokenDecimals(quoteToken);
+        console.log("Quote token decimals:", quoteDecimals);
+        const marketCap = parseUnits(
+          cfg.pool?.initialMarketCap ?? "100",
+          quoteDecimals
+        );
+        const tick = await this.calculateTickForQuoteToken(
+          quoteToken,
+          marketCap
+        );
+        let initialBuyConfig = {
+          pairedTokenPoolFee: 1e4,
+          // Default to 1%
+          pairedTokenSwapAmountOutMinimum: BigInt(0),
+          ethAmount: void 0
+        };
+        if (cfg.devBuy) {
+          const ethAmount = parseEther(cfg.devBuy.ethAmount);
+          const { fee, sqrtPriceX96 } = await this.findMostLiquidPool(quoteToken);
+          const minOutput = this.calculateMinimumOutput(
+            ethAmount,
+            sqrtPriceX96,
+            quoteDecimals,
+            cfg.devBuy.maxSlippage ?? 5
+          );
+          initialBuyConfig = {
+            pairedTokenPoolFee: fee,
+            pairedTokenSwapAmountOutMinimum: minOutput,
+            ethAmount
+          };
+          console.log("Dev buy configuration:", {
+            ethAmount: cfg.devBuy.ethAmount,
+            fee,
+            minOutput: minOutput.toString()
+          });
+        }
+        const deployerAddress = this.wallet?.account?.address ?? "0x0000000000000000000000000000000000000000";
+        return {
+          tokenConfig: {
+            name: cfg.name,
+            symbol: cfg.symbol,
+            salt: cfg.salt || "0x0000000000000000000000000000000000000000000000000000000000000000",
+            image: cfg.image || "https://ipfs.io/ipfs/QmcjfTeK3tpK3MVCQuvEaXvSscrqbL3MwsEo8LdBTWabY4",
+            metadata: JSON.stringify(cfg.metadata || {
+              description: "Clanker Token",
+              socialMediaUrls: [],
+              auditUrls: []
+            }),
+            context: JSON.stringify(cfg.context || {
+              interface: "Clanker SDK",
+              platform: "Clanker",
+              messageId: "Clanker SDK",
+              id: "Clanker SDK"
+            }),
+            originatingChainId: BigInt(this.publicClient.chain.id)
+          },
+          poolConfig: {
+            pairedToken: quoteToken,
+            tickIfToken0IsNewToken: tick,
+            initialMarketCapInPairedToken: marketCap
+          },
+          vaultConfig: cfg.vault ? {
+            vaultPercentage: cfg.vault.percentage,
+            vaultDuration: BigInt(cfg.vault.durationInDays * 24 * 60 * 60)
+          } : {
+            vaultPercentage: 0,
+            vaultDuration: 0n
+          },
+          initialBuyConfig,
+          rewardsConfig: {
+            creatorReward: BigInt(40),
+            // Default to 40% creator reward
+            creatorAdmin: deployerAddress,
+            creatorRewardRecipient: deployerAddress,
+            interfaceAdmin: deployerAddress,
+            interfaceRewardRecipient: deployerAddress
+          }
+        };
+      }
+      /**
+       * Creates calldata (+ msg.value) **without** sending a transaction.
+       * This version no longer relies on viem's `simulateContract`, which
+       * was returning an object without `.data`.  We now ABI-encode the
+       * call manually so `data` is always defined.
+       */
+      async prepareDeployToken(cfg) {
+        const deploymentConfig = await this.buildDeploymentConfig(cfg);
+        const data = encodeFunctionData({
+          abi: Clanker_v3_1_abi,
+          functionName: "deployToken",
+          args: [deploymentConfig]
+        });
+        const value = deploymentConfig.initialBuyConfig?.ethAmount ?? 0n;
+        return {
+          to: this.factoryAddress,
+          data,
+          // 0x-prefixed hex string (non-empty)
+          value
+        };
+      }
+      async deployToken(cfg) {
+        if (!this.wallet) throw new Error("Wallet client required for deployToken");
+        if (!this.wallet.account) throw new Error("Wallet account required for deployToken");
+        const tx = await this.prepareDeployToken(cfg);
+        const hash = await this.wallet.sendTransaction({
+          ...tx,
+          account: this.wallet.account,
+          chain: this.publicClient.chain
+        });
+        const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+        const [log] = parseEventLogs({
+          abi: Clanker_v3_1_abi,
+          eventName: "TokenCreated",
+          logs: receipt.logs
+        });
+        if (!log) throw new Error("No deployment event found");
+        return log.args.tokenAddress;
+      }
+    };
+  }
+});
+
+// src/cli/create-clanker.ts
+var create_clanker_exports = {};
+__export(create_clanker_exports, {
+  default: () => createClanker
+});
+import inquirer from "inquirer";
+import { createPublicClient, createWalletClient, http } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { base } from "viem/chains";
+import * as dotenv from "dotenv";
+async function createClanker() {
+  const args = process.argv.slice(2);
+  if (args.length === 0 || args[0] !== "--create" && args[0] !== "create") {
+    console.log("\n\u{1F680} Clanker SDK CLI\n");
+    console.log("Available commands:");
+    console.log("  --create    Create a new token");
+    console.log("\nExample:");
+    console.log("  npx clanker-sdk --create\n");
+    process.exit(0);
+  }
+  const PRIVATE_KEY = process.env.PRIVATE_KEY;
+  const FACTORY_ADDRESS = process.env.FACTORY_ADDRESS;
+  const RPC_URL = process.env.RPC_URL;
+  const WETH_ADDRESS2 = "0x4200000000000000000000000000000000000006";
+  const USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+  function checkEnvironment() {
+    const missingVars = [];
+    if (!PRIVATE_KEY) missingVars.push("PRIVATE_KEY");
+    if (!FACTORY_ADDRESS) missingVars.push("FACTORY_ADDRESS");
+    if (missingVars.length > 0) {
+      console.log("\n\u274C Missing required environment variables:");
+      console.log(missingVars.join(", "));
+      console.log("\n\u{1F4DD} Please create a .env file in your current directory with the following variables:");
+      console.log(`
+Required:
+PRIVATE_KEY=your_private_key_here
+FACTORY_ADDRESS=factory_contract_address_here
+
+Optional:
+RPC_URL=your_custom_rpc_url (if not provided, will use default Base RPC)
+      `);
+      console.log("\nMake sure to include the 0x prefix for addresses and private keys.");
+      console.log("Never share or commit your private key!\n");
+      return false;
+    }
+    if (!PRIVATE_KEY.startsWith("0x") || PRIVATE_KEY.length !== 66) {
+      console.log("\n\u274C Invalid PRIVATE_KEY format. It should:");
+      console.log("- Start with 0x");
+      console.log("- Be 64 characters long (plus 0x prefix)");
+      return false;
+    }
+    if (!FACTORY_ADDRESS.startsWith("0x") || FACTORY_ADDRESS.length !== 42) {
+      console.log("\n\u274C Invalid FACTORY_ADDRESS format. It should:");
+      console.log("- Start with 0x");
+      console.log("- Be 40 characters long (plus 0x prefix)");
+      return false;
+    }
+    return true;
+  }
+  const validateAddress = (input) => {
+    if (!input) return "Address cannot be empty";
+    if (!/^0x[a-fA-F0-9]{40}$/.test(input)) return "Invalid Ethereum address";
+    return true;
+  };
+  const validatePercentage = (input) => {
+    const num = Number(input);
+    if (isNaN(num)) return "Must be a number";
+    if (num < 0 || num > 100) return "Percentage must be between 0 and 100";
+    return true;
+  };
+  const validateSymbol = (input) => {
+    if (!input) return "Symbol cannot be empty";
+    if (!/^[A-Z0-9]+$/.test(input)) return "Symbol must contain only uppercase letters and numbers";
+    if (input.length > 10) return "Symbol must be 10 characters or less";
+    return true;
+  };
+  const validateIpfsUri = (input) => {
+    if (!input) return "Image URI cannot be empty";
+    if (!input.startsWith("ipfs://")) return "Image URI must start with ipfs://";
+    return true;
+  };
+  const validateAmount = (input) => {
+    if (!input) return "Amount cannot be empty";
+    if (!/^\d*\.?\d+$/.test(input)) return "Must be a valid number";
+    return true;
+  };
+  const validateHexString = (input) => {
+    if (!input) return true;
+    if (!/^0x[a-fA-F0-9]+$/.test(input)) return "Must be a valid hex string starting with 0x";
+    return true;
+  };
+  const validateSlippage = (input) => {
+    const num = Number(input);
+    if (isNaN(num)) return "Must be a number";
+    if (num < 0 || num > 100) return "Slippage must be between 0 and 100";
+    return true;
+  };
+  const validateVaultPercentage = (input) => {
+    const num = Number(input);
+    if (isNaN(num)) return "Must be a number";
+    if (num < 0 || num > 30) return "Vault percentage must be between 0 and 30%";
+    return true;
+  };
+  const validateVaultDuration = (input) => {
+    const num = Number(input);
+    if (isNaN(num)) return "Must be a number";
+    if (num < 30) return "Vault duration must be at least 30 days";
+    return true;
+  };
+  const validateCreatorReward = (input) => {
+    const num = Number(input);
+    if (isNaN(num)) return "Must be a number";
+    if (num < 0 || num > 80) return "Creator reward must be between 0 and 80%";
+    return true;
+  };
+  const validateUrl = (input) => {
+    if (!input) return true;
+    try {
+      new URL(input);
+      return true;
+    } catch (e) {
+      return "Please enter a valid URL";
+    }
+  };
+  async function promptUser() {
+    const questions = [
+      {
+        type: "input",
+        name: "name",
+        message: "Token name:",
+        validate: (input) => input.length > 0 || "Name cannot be empty"
+      },
+      {
+        type: "input",
+        name: "symbol",
+        message: "Token symbol:",
+        validate: validateSymbol
+      },
+      {
+        type: "list",
+        name: "pairedTokenChoice",
+        message: "Select quote token:",
+        choices: [
+          { name: "WETH", value: "WETH" },
+          { name: "USDC", value: "USDC" },
+          { name: "Custom Address", value: "CUSTOM" }
+        ],
+        default: "WETH"
+      },
+      {
+        type: "input",
+        name: "customPairedToken",
+        message: "Enter custom token address:",
+        validate: validateAddress,
+        when: (answers2) => answers2.pairedTokenChoice === "CUSTOM"
+      },
+      {
+        type: "input",
+        name: "initialMarketCapUsd",
+        message: (answers2) => `Enter initial market cap in ${answers2.pairedTokenChoice === "CUSTOM" ? "quote token" : answers2.pairedTokenChoice}:`,
+        validate: validateAmount,
+        default: (answers2) => answers2.pairedTokenChoice === "WETH" ? "1" : answers2.pairedTokenChoice === "USDC" ? "1000" : "1"
+      },
+      {
+        type: "input",
+        name: "customMarketCap",
+        message: "Enter custom market cap in quote token:",
+        validate: validateAmount,
+        when: (answers2) => answers2.initialMarketCapUsd === "CUSTOM"
+      },
+      {
+        type: "input",
+        name: "image",
+        message: "Enter the IPFS URI for the token image:",
+        validate: validateIpfsUri
+      },
+      {
+        type: "list",
+        name: "devBuy.ethAmount",
+        message: "Creator buy amount (optional):",
+        choices: [
+          { name: "None", value: "0" },
+          { name: "0.00005 ETH", value: "0.00005" },
+          { name: "0.1 ETH", value: "0.1" },
+          { name: "0.5 ETH", value: "0.5" },
+          { name: "1.0 ETH", value: "1.0" },
+          { name: "Custom", value: "CUSTOM" }
+        ],
+        default: "0"
+      },
+      {
+        type: "input",
+        name: "customDevBuy",
+        message: "Enter custom dev buy amount in ETH:",
+        validate: validateAmount,
+        when: (answers2) => answers2.devBuy.ethAmount === "CUSTOM"
+      },
+      {
+        type: "input",
+        name: "devBuy.maxSlippage",
+        message: "Maximum slippage percentage (0-100):",
+        validate: validateSlippage,
+        default: "5",
+        when: (answers2) => answers2.devBuy.ethAmount !== "0"
+      },
+      {
+        type: "list",
+        name: "vaultConfig.vaultPercentage",
+        message: "Vault percentage (optional):",
+        choices: [
+          { name: "None", value: "0" },
+          { name: "5%", value: "5" },
+          { name: "15%", value: "15" },
+          { name: "30%", value: "30" },
+          { name: "Custom", value: "CUSTOM" }
+        ],
+        default: "0"
+      },
+      {
+        type: "input",
+        name: "customVaultPercentage",
+        message: "Enter custom vault percentage (0-30):",
+        validate: validateVaultPercentage,
+        when: (answers2) => answers2.vaultConfig.vaultPercentage === "CUSTOM"
+      },
+      {
+        type: "list",
+        name: "vaultConfig.durationInDays",
+        message: "Vault duration:",
+        choices: [
+          { name: "31 days", value: "31" },
+          { name: "90 days", value: "90" },
+          { name: "180 days", value: "180" },
+          { name: "Custom", value: "CUSTOM" }
+        ],
+        default: "31",
+        when: (answers2) => answers2.vaultConfig.vaultPercentage !== "0"
+      },
+      {
+        type: "input",
+        name: "customVaultDuration",
+        message: "Enter custom vault duration in days (minimum 30):",
+        validate: validateVaultDuration,
+        when: (answers2) => answers2.vaultConfig.durationInDays === "CUSTOM"
+      },
+      {
+        type: "input",
+        name: "metadata.description",
+        message: "Token description:",
+        default: (answers2) => `${answers2.name} token deployed via Clanker CLI`,
+        validate: (input) => input.length > 0 || "Description cannot be empty"
+      },
+      {
+        type: "input",
+        name: "metadata.telegram",
+        message: "Telegram URL (optional):",
+        validate: validateUrl
+      },
+      {
+        type: "input",
+        name: "metadata.website",
+        message: "Website URL (optional):",
+        validate: validateUrl
+      },
+      {
+        type: "input",
+        name: "metadata.twitter",
+        message: "X/Twitter URL (optional):",
+        validate: validateUrl
+      },
+      {
+        type: "input",
+        name: "metadata.farcaster",
+        message: "Farcaster URL (optional):",
+        validate: validateUrl
+      }
+    ];
+    const answers = await inquirer.prompt(questions);
+    if (answers.initialMarketCapUsd === "CUSTOM") {
+      answers.initialMarketCapUsd = answers.customMarketCap || "0";
+    }
+    if (answers.devBuy.ethAmount === "CUSTOM") {
+      answers.devBuy.ethAmount = answers.customDevBuy || "0";
+    }
+    const vaultPercentage = answers.vaultConfig.vaultPercentage === "CUSTOM" ? parseInt(answers.customVaultPercentage || "0", 10) : parseInt(answers.vaultConfig.vaultPercentage, 10);
+    const vaultDuration = answers.vaultConfig.durationInDays === "CUSTOM" ? parseInt(answers.customVaultDuration || "31", 10) : parseInt(answers.vaultConfig.durationInDays, 10);
+    const socialMediaUrls = [];
+    if (answers.metadata.telegram) socialMediaUrls.push(answers.metadata.telegram);
+    if (answers.metadata.website) socialMediaUrls.push(answers.metadata.website);
+    if (answers.metadata.twitter) socialMediaUrls.push(answers.metadata.twitter);
+    if (answers.metadata.farcaster) socialMediaUrls.push(answers.metadata.farcaster);
+    const metadata = {
+      description: answers.metadata.description,
+      socialMediaUrls,
+      auditUrls: []
+    };
+    return {
+      ...answers,
+      metadata,
+      vaultConfig: {
+        vaultPercentage: vaultPercentage.toString(),
+        durationInDays: vaultDuration.toString()
+      }
+    };
+  }
+  async function deployToken(answers) {
+    if (!PRIVATE_KEY || !FACTORY_ADDRESS) {
+      throw new Error("Missing required environment variables (PRIVATE_KEY, FACTORY_ADDRESS)");
+    }
+    const account = privateKeyToAccount(PRIVATE_KEY);
+    const transport = RPC_URL ? http(RPC_URL) : http();
+    const publicClient = createPublicClient({
+      chain: base,
+      transport
+    });
+    const walletClient = createWalletClient({
+      account,
+      chain: base,
+      transport
+    });
+    const clanker = new Clanker({
+      wallet: walletClient,
+      publicClient,
+      factoryAddress: FACTORY_ADDRESS
+    });
+    console.log("\n\u{1F504} Preparing deployment configuration...");
+    let quoteToken;
+    let decimals;
+    switch (answers.pairedTokenChoice) {
+      case "WETH":
+        quoteToken = WETH_ADDRESS2;
+        decimals = 18;
+        break;
+      case "USDC":
+        quoteToken = USDC_ADDRESS;
+        decimals = 6;
+        break;
+      case "CUSTOM":
+        quoteToken = answers.customPairedToken;
+        decimals = 18;
+        break;
+      default:
+        quoteToken = WETH_ADDRESS2;
+        decimals = 18;
+    }
+    const tokenAddress = await clanker.deployToken({
+      name: answers.name,
+      symbol: answers.symbol,
+      salt: answers.salt || "0x0000000000000000000000000000000000000000000000000000000000000000",
+      image: answers.image,
+      metadata: {
+        description: `${answers.name} token deployed via Clanker CLI`,
+        socialMediaUrls: [],
+        auditUrls: []
+      },
+      context: {
+        interface: "Clanker CLI",
+        platform: "Clanker",
+        messageId: `CLI-${Date.now()}`,
+        id: `${answers.symbol}-${Date.now()}`
+      },
+      vault: answers.vaultConfig.vaultPercentage !== "0" ? {
+        percentage: parseInt(answers.vaultConfig.vaultPercentage, 10),
+        durationInDays: parseInt(answers.vaultConfig.durationInDays, 10)
+      } : void 0,
+      pool: {
+        quoteToken,
+        initialMarketCap: answers.initialMarketCapUsd
+        // Pass raw value, SDK will handle decimals
+      },
+      devBuy: answers.devBuy.ethAmount !== "0" ? {
+        ethAmount: answers.devBuy.ethAmount,
+        maxSlippage: answers.devBuy.maxSlippage
+      } : void 0
+    });
+    return tokenAddress;
+  }
+  async function main2() {
+    console.log("\n\u{1F680} Welcome to the Clanker Token Creator! \u{1F680}\n");
+    if (!checkEnvironment()) {
+      process.exit(1);
+    }
+    try {
+      const answers = await promptUser();
+      console.log("\n\u{1F4DD} Review your token configuration:\n");
+      console.log(JSON.stringify(answers, null, 2));
+      const { confirm } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "confirm",
+          message: "Would you like to proceed with deployment?",
+          default: false
+        }
+      ]);
+      if (confirm) {
+        console.log("\n\u{1F504} Deploying your token...");
+        try {
+          const tokenAddress = await deployToken(answers);
+          console.log("\n\u2728 Token deployed successfully!");
+          console.log("\u{1F4CD} Token address:", tokenAddress);
+          console.log("\n\u{1F310} View on Basescan:");
+          console.log(`https://basescan.org/token/${tokenAddress}`);
+        } catch (error) {
+          console.error("\n\u274C Deployment failed:", error instanceof Error ? error.message : "Unknown error");
+          process.exit(1);
+        }
+      } else {
+        console.log("\n\u274C Deployment cancelled");
+      }
+    } catch (error) {
+      console.error("\n\u274C Error:", error);
+      process.exit(1);
+    }
+  }
+  await main2();
+}
+var init_create_clanker = __esm({
+  "src/cli/create-clanker.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_index();
+    dotenv.config();
+    createClanker();
+  }
+});
+
+// src/cli/cli.ts
+init_esm_shims();
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes("--create")) {
+    const createClanker2 = await Promise.resolve().then(() => (init_create_clanker(), create_clanker_exports));
+    await createClanker2.default();
+  } else {
+    console.log("\n\u{1F680} Clanker SDK CLI\n");
+    console.log("Available commands:");
+    console.log("  --create    Create a new token");
+    console.log("\nExample:");
+    console.log("  npx clanker-sdk --create\n");
+    process.exit(0);
+  }
+}
+main().catch((error) => {
+  console.error("Error:", error);
+  process.exit(1);
+});