clanker-sdk 4.2.7 → 4.2.9

package/dist/cli/cli.js

@@ -9,12 +9,12 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// node_modules/tsup/assets/esm_shims.js
+// node_modules/.pnpm/tsup@8.4.0_typescript@5.8.3/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/tsup/assets/esm_shims.js"() {
+  "node_modules/.pnpm/tsup@8.4.0_typescript@5.8.3/node_modules/tsup/assets/esm_shims.js"() {
     "use strict";
     getFilename = () => fileURLToPath(import.meta.url);
     getDirname = () => path.dirname(getFilename());
@@ -6748,7 +6748,11 @@ var init_write_clanker_contracts = __esm({
         }
       }
       try {
-        const txHash = await writeContract(wallet, tx);
+        const txHash = await writeContract(wallet, {
+          ...tx,
+          dataSuffix: tx.dataSuffix
+          // biome-ignore lint/suspicious/noExplicitAny: It's difficult to type tx correctly with viem's generic constraints
+        });
         return { txHash };
       } catch (e) {
         return { error: understandError(e) };
@@ -6769,7 +6773,7 @@ async function simulateDeployToken(tx, account, publicClient) {
   }
   return simulateClankerContract(publicClient, account, tx);
 }
-async function deployToken(tx, wallet, publicClient) {
+async function deployToken(tx, wallet, publicClient, options) {
   const account = wallet?.account;
   if (!account) {
     throw new Error("Wallet account required for deployToken");
@@ -6784,14 +6788,18 @@ async function deployToken(tx, wallet, publicClient) {
       `Token chainId doesn't match wallet chainId: ${tx.chainId} != ${wallet.chain?.id}`
     );
   }
-  const { gas, error: gasError } = await estimateGasClankerContract(publicClient, account, tx);
+  const { gas, error: gasError } = await estimateGasClankerContract(publicClient, account, {
+    ...tx,
+    dataSuffix: options?.dataSuffix
+  });
   if (gasError) return { error: gasError };
   const { txHash, error: txError } = await writeClankerContract(
     publicClient,
     wallet,
     {
       ...tx,
-      gas: gas * 12n / 10n
+      gas: gas * 12n / 10n,
+      dataSuffix: options?.dataSuffix
     },
     {
       simulate: true

package/dist/cli/create-clanker.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// node_modules/tsup/assets/esm_shims.js
+// node_modules/.pnpm/tsup@8.4.0_typescript@5.8.3/node_modules/tsup/assets/esm_shims.js
 import { fileURLToPath } from "url";
 import path from "path";
 var getFilename = () => fileURLToPath(import.meta.url);
@@ -6599,7 +6599,11 @@ var writeClankerContract = async (client, wallet, tx, options) => {
     }
   }
   try {
-    const txHash = await writeContract(wallet, tx);
+    const txHash = await writeContract(wallet, {
+      ...tx,
+      dataSuffix: tx.dataSuffix
+      // biome-ignore lint/suspicious/noExplicitAny: It's difficult to type tx correctly with viem's generic constraints
+    });
     return { txHash };
   } catch (e) {
     return { error: understandError(e) };
@@ -6615,7 +6619,7 @@ async function simulateDeployToken(tx, account, publicClient) {
   }
   return simulateClankerContract(publicClient, account, tx);
 }
-async function deployToken(tx, wallet, publicClient) {
+async function deployToken(tx, wallet, publicClient, options) {
   const account = wallet?.account;
   if (!account) {
     throw new Error("Wallet account required for deployToken");
@@ -6630,14 +6634,18 @@ async function deployToken(tx, wallet, publicClient) {
       `Token chainId doesn't match wallet chainId: ${tx.chainId} != ${wallet.chain?.id}`
     );
   }
-  const { gas, error: gasError } = await estimateGasClankerContract(publicClient, account, tx);
+  const { gas, error: gasError } = await estimateGasClankerContract(publicClient, account, {
+    ...tx,
+    dataSuffix: options?.dataSuffix
+  });
   if (gasError) return { error: gasError };
   const { txHash, error: txError } = await writeClankerContract(
     publicClient,
     wallet,
     {
       ...tx,
-      gas: gas * 12n / 10n
+      gas: gas * 12n / 10n,
+      dataSuffix: options?.dataSuffix
     },
     {
       simulate: true

package/dist/{clankerTokenV4-nI7uj0d1.d.ts → deploy-BvFgwMVl.d.ts}

@@ -18134,4 +18134,9 @@ declare function encodeFeeConfig(tokenConfig: z.infer<typeof clankerTokenV4>, cl
     poolData: `0x${string}`;
 };
 
-export { type ClankerTokenV4 as C, type RelatedV3_1 as R, type Type as T, type Chain as a, type ClankerDeployment as b, type RelatedV4 as c, CLANKERS as d, encodeFeeConfig as e, type Clankers as f, Chains as g, ClankerDeployments as h, clankerConfigFor as i };
+type DeployTokenOptions = {
+    /** Data to append to the end of the transaction calldata (e.g., Base builder codes) */
+    dataSuffix?: `0x${string}`;
+};
+
+export { type ClankerTokenV4 as C, type DeployTokenOptions as D, type RelatedV3_1 as R, type Type as T, type Chain as a, type ClankerDeployment as b, type RelatedV4 as c, CLANKERS as d, encodeFeeConfig as e, type Clankers as f, Chains as g, ClankerDeployments as h, clankerConfigFor as i };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { C as ClankerTokenV3 } from './clankerTokenV3-BqHTF9QY.js';
-import { a as Chain, C as ClankerTokenV4, b as ClankerDeployment } from './clankerTokenV4-nI7uj0d1.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-nI7uj0d1.js';
+import { a as Chain, C as ClankerTokenV4, b as ClankerDeployment } from './deploy-BvFgwMVl.js';
+export { d as CLANKERS, g as Chains, h as ClankerDeployments, f as Clankers, D as DeployTokenOptions, R as RelatedV3_1, c as RelatedV4, T as Type, i as clankerConfigFor } from './deploy-BvFgwMVl.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';

package/dist/legacyFeeClaims/index.d.ts

@@ -1,6 +1,308 @@
-import { WalletClient, Transport, Chain, Account, PublicClient } from 'viem';
+import * as viem from 'viem';
+import { Abi, WalletClient, Transport, Chain, Account, PublicClient } from 'viem';
 import { C as ClankerError } from '../errors-5Gv28Tkr.js';
 
+/**
+ * Clanker factory addresses on Base by version
+ */
+declare const LEGACY_FACTORIES: {
+    readonly 0: "0x250c9FB2b411B48273f69879007803790A6AeA47";
+    readonly 1: "0x9B84fcE5Dcd9a38d2D01d5D72373F6b6b067c3e1";
+    readonly 2: "0x732560fa1d1A76350b1A500155BA978031B53833";
+    readonly 3: "0x375C15db32D28cEcdcAB5C03Ab889bf15cbD2c5E";
+    readonly 3.1: "0x2A787b2362021cC3eEa3C24C4748a6cD5B687382";
+};
+type LegacyVersion = 0 | 1 | 2 | 3 | 3.1;
+type LegacyFeeClaimsConfig$1 = {
+    wallet?: WalletClient<Transport, Chain, Account>;
+    publicClient?: PublicClient;
+};
+/**
+ * Transaction config for legacy fee claiming.
+ * Compatible with walletClient.writeContract()
+ */
+type LegacyClaimTransactionConfig = {
+    address: `0x${string}`;
+    abi: Abi;
+    functionName: string;
+    args: readonly unknown[];
+};
+/**
+ * v0/v1 locker params - required for versions 0 and 1
+ */
+type LockerParams = {
+    /** The locker contract address that holds the LP position */
+    locker: `0x${string}`;
+    /** The Uniswap V3 position NFT ID */
+    positionId: bigint;
+    /** The address to receive the fees */
+    recipient: `0x${string}`;
+};
+/**
+ * Input for claiming legacy creator fees.
+ *
+ * For v2/v3/v3.1: Only `token` and `version` are required.
+ * For v0/v1: Additional `lockerParams` are required.
+ */
+type ClaimLegacyCreatorFeesInput = {
+    /** The Clanker token address */
+    token: `0x${string}`;
+    /** Token version */
+    version: 2 | 3 | 3.1;
+} | {
+    /** The Clanker token address */
+    token: `0x${string}`;
+    /** Token version */
+    version: 0 | 1;
+    /** Required for v0/v1: locker info from TokenCreated event */
+    lockerParams: LockerParams;
+};
+/**
+ * Legacy Creator Fee Claims for Clanker v0–v3.1 on Base.
+ *
+ * @example
+ * ```ts
+ * const clanker = new LegacyCreatorFees({ wallet, publicClient });
+ *
+ * // v2/v3/v3.1 - simple!
+ * await clanker.claimLegacyCreatorFees({ token: '0x...', version: 3.1 });
+ *
+ * // v0/v1 - need locker info
+ * await clanker.claimLegacyCreatorFees({
+ *   token: '0x...',
+ *   version: 1,
+ *   lockerParams: { locker: '0x...', positionId: 123n, recipient: '0x...' }
+ * });
+ * ```
+ */
+declare class LegacyCreatorFees {
+    readonly wallet?: WalletClient<Transport, Chain, Account>;
+    readonly publicClient?: PublicClient;
+    constructor(config?: LegacyFeeClaimsConfig$1);
+    private assertBase;
+    /**
+     * Get a transaction config for claiming legacy creator fees.
+     *
+     * @param input Token address, version, and locker params (for v0/v1)
+     * @returns Transaction config
+     */
+    getClaimLegacyCreatorFeesTransaction(input: ClaimLegacyCreatorFeesInput): LegacyClaimTransactionConfig;
+    /**
+     * Get a transaction config for claiming via meta-locker (some v0 tokens).
+     *
+     * @param locker The locker contract address
+     * @param positionId The Uniswap V3 position NFT ID
+     * @returns Transaction config
+     */
+    getMetaLockerClaimTransaction(locker: `0x${string}`, positionId: bigint): LegacyClaimTransactionConfig;
+    /**
+     * Simulate claiming legacy creator fees.
+     *
+     * @param input Token address, version, and locker params (for v0/v1)
+     * @param account Optional account to simulate from
+     * @returns Simulation result or error
+     */
+    claimLegacyCreatorFeesSimulate(input: ClaimLegacyCreatorFeesInput, account?: Account): Promise<viem.SimulateContractReturnType<Abi | readonly unknown[], string, readonly unknown[], Chain | undefined, undefined, undefined, undefined, readonly [never], undefined> | {
+        error: ClankerError;
+    }>;
+    /**
+     * Claim legacy creator fees.
+     *
+     * @param input Token address, version, and locker params (for v0/v1)
+     * @returns Transaction hash or error
+     */
+    claimLegacyCreatorFees(input: ClaimLegacyCreatorFeesInput): Promise<{
+        txHash: `0x${string}`;
+        error: undefined;
+    } | {
+        txHash: undefined;
+        error: ClankerError;
+    }>;
+}
+/**
+ * Get a transaction config for claiming legacy creator fees.
+ *
+ * @param input Token address, version, and locker params (for v0/v1)
+ * @returns Transaction config
+ *
+ * @example
+ * ```ts
+ * // v3.1 token - simple
+ * const tx = getClaimLegacyCreatorFeesTransaction({
+ *   token: '0x...',
+ *   version: 3.1
+ * });
+ *
+ * // v1 token - need locker info
+ * const tx = getClaimLegacyCreatorFeesTransaction({
+ *   token: '0x...',
+ *   version: 1,
+ *   lockerParams: { locker: '0x...', positionId: 123n, recipient: '0x...' }
+ * });
+ *
+ * await walletClient.writeContract(tx);
+ * ```
+ */
+declare function getClaimLegacyCreatorFeesTransaction(input: ClaimLegacyCreatorFeesInput): LegacyClaimTransactionConfig;
+
+/**
+ * Base chain ID
+ */
+declare const BASE_CHAIN_ID: 8453;
+/**
+ * Uniswap V3 addresses on Base
+ */
+declare const UNISWAP_V3_BASE: {
+    readonly factory: "0x33128a8fC17869897dcE68Ed026d694621f6FDfD";
+    readonly nonfungiblePositionManager: "0x03a520b32C04BF3bEEf7BEb72E919cf822Ed34f1";
+    readonly weth: "0x4200000000000000000000000000000000000006";
+};
+/**
+ * Clanker factories on Base (v0–v3.1)
+ */
+declare const CLANKER_FACTORIES_BASE: {
+    readonly clanker_v0: "0x250c9FB2b411B48273f69879007803790A6AeA47";
+    readonly clanker_v1: "0x9B84fcE5Dcd9a38d2D01d5D72373F6b6b067c3e1";
+    readonly clanker_v2: "0x732560fa1d1A76350b1A500155BA978031B53833";
+    readonly clanker_v3: "0x375C15db32D28cEcdcAB5C03Ab889bf15cbD2c5E";
+    readonly clanker_v3_presale: "0x71cDc0bDF30F5601fb0ac80Cf1d20B771342C035";
+    readonly clanker_v3_1: "0x2A787b2362021cC3eEa3C24C4748a6cD5B687382";
+};
+/**
+ * Legacy token type labels for v0–v3.1
+ */
+type LegacyTokenType = 'proxy' | 'clanker' | 'clanker_v2' | 'clanker_v3' | 'clanker_v3_1';
+declare const ClankerClaimRewardsAbi: readonly [{
+    readonly type: "function";
+    readonly name: "claimRewards";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [];
+}];
+declare const LockerCollectFeesAbi: readonly [{
+    readonly type: "function";
+    readonly name: "collectFees";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "_recipient";
+        readonly type: "address";
+    }, {
+        readonly name: "_tokenId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [];
+}];
+declare const MetaLockerCollectFeesAbi: readonly [{
+    readonly type: "function";
+    readonly name: "collectFees";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "_tokenId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [];
+}];
+declare const ClankerTokenDeployerAbi: readonly [{
+    readonly type: "function";
+    readonly name: "deployer";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+    }];
+}];
+declare const NonfungiblePositionManagerOwnerOfAbi: readonly [{
+    readonly type: "function";
+    readonly name: "ownerOf";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+    }];
+}];
+declare const NonfungiblePositionManagerPositionsAbi: readonly [{
+    readonly type: "function";
+    readonly name: "positions";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "nonce";
+        readonly type: "uint96";
+    }, {
+        readonly name: "operator";
+        readonly type: "address";
+    }, {
+        readonly name: "token0";
+        readonly type: "address";
+    }, {
+        readonly name: "token1";
+        readonly type: "address";
+    }, {
+        readonly name: "fee";
+        readonly type: "uint24";
+    }, {
+        readonly name: "tickLower";
+        readonly type: "int24";
+    }, {
+        readonly name: "tickUpper";
+        readonly type: "int24";
+    }, {
+        readonly name: "liquidity";
+        readonly type: "uint128";
+    }, {
+        readonly name: "feeGrowthInside0LastX128";
+        readonly type: "uint256";
+    }, {
+        readonly name: "feeGrowthInside1LastX128";
+        readonly type: "uint256";
+    }, {
+        readonly name: "tokensOwed0";
+        readonly type: "uint128";
+    }, {
+        readonly name: "tokensOwed1";
+        readonly type: "uint128";
+    }];
+}];
+declare const NonfungiblePositionManagerCollectAbi: readonly [{
+    readonly type: "function";
+    readonly name: "collect";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly name: "params";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "tokenId";
+            readonly type: "uint256";
+        }, {
+            readonly name: "recipient";
+            readonly type: "address";
+        }, {
+            readonly name: "amount0Max";
+            readonly type: "uint128";
+        }, {
+            readonly name: "amount1Max";
+            readonly type: "uint128";
+        }];
+    }];
+    readonly outputs: readonly [{
+        readonly name: "amount0";
+        readonly type: "uint256";
+    }, {
+        readonly name: "amount1";
+        readonly type: "uint256";
+    }];
+}];
 /**
  * Contract address for ClankerSafeErc20Spender on Base network
  */
@@ -9,6 +311,54 @@ type LegacyFeeClaimsConfig = {
     wallet?: WalletClient<Transport, Chain, Account>;
     publicClient?: PublicClient;
 };
+/**
+ * Input arguments for building a legacy fee claim transaction
+ */
+type LegacyClaimArgs = {
+    /** Must be 8453 (Base) */
+    chainId: number;
+    /** The Clanker token contract address */
+    token: `0x${string}`;
+    /** Token type label (proxy, clanker, clanker_v2, clanker_v3, clanker_v3_1) */
+    tokenType?: LegacyTokenType;
+    /** Factory address (required for v2–v3.1 factory claim) */
+    factory?: `0x${string}`;
+    /** Locker address (required for v0–v1 locker claim) */
+    locker?: `0x${string}`;
+    /** Uniswap V3 position NFT ID (required for v0–v1 claim and claimable estimation) */
+    positionId?: bigint;
+    /** Recipient address (required for Locker.collectFees) */
+    recipient?: `0x${string}`;
+    /** Wallet address for v1 deployer gating and optional simulate account */
+    walletAddress?: `0x${string}`;
+};
+/** @deprecated Use LegacyClaimArgs instead */
+type LegacyClaimFeesInput = LegacyClaimArgs;
+/**
+ * Transaction kind for legacy fee claims
+ */
+type LegacyClaimTxKind = 'factory.claimRewards' | 'locker.collectFees' | 'metaLocker.collectFees';
+/**
+ * Transaction output for legacy fee claims
+ */
+type LegacyClaimTx = {
+    kind: LegacyClaimTxKind;
+    to: `0x${string}`;
+    data: `0x${string}`;
+    value?: bigint;
+};
+/** @deprecated Use LegacyClaimTx instead */
+type LegacyClaimFeesTransaction = LegacyClaimTx;
+/**
+ * Result of estimating claimable fees
+ */
+type LegacyClaimableFees = {
+    positionOwner: `0x${string}`;
+    token0: `0x${string}`;
+    token1: `0x${string}`;
+    amount0: bigint;
+    amount1: bigint;
+};
 /**
  * SDK for claiming legacy fees from Clanker v0-v3.1 tokens.
  *
@@ -24,6 +374,24 @@ declare class LegacyFeeClaims {
     readonly wallet?: WalletClient<Transport, Chain, Account>;
     readonly publicClient?: PublicClient;
     constructor(config?: LegacyFeeClaimsConfig);
+    private assertBaseChain;
+    /**
+     * Build a Base-only transaction for claiming legacy fees (v0-v3.1).
+     *
+     * @param args Claim arguments
+     * @returns Transaction object with { kind, to, data, value? }
+     */
+    getClaimLegacyFeesTransaction(args: LegacyClaimArgs): Promise<LegacyClaimTx>;
+    /**
+     * Estimate claimable Uniswap v3 LP fees for a legacy position on Base.
+     *
+     * @param opts Options with chainId and positionId
+     * @returns Claimable fees with position owner, token0, token1, amount0, amount1
+     */
+    getLegacyClaimableFees(opts: {
+        chainId: number;
+        positionId: bigint;
+    }): Promise<LegacyClaimableFees>;
     /**
      * Get an abi-typed transaction for initializing token creator ownership.
      *
@@ -2682,5 +3050,29 @@ declare function getTokenCreatorTransferTransaction({ safe, token, recipient, }:
     functionName: "tokenCreatorTransfer";
     args: readonly [`0x${string}`, `0x${string}`, `0x${string}`];
 };
+/**
+ * Build a claim transaction for legacy Clanker v0–v3.1 fees on Base.
+ *
+ * - v2/v3/v3.1: call factory.claimRewards(token)
+ * - v0/v1: call locker.collectFees(recipient, tokenId) or metaLocker.collectFees(tokenId)
+ *
+ * @param publicClient Viem public client for Base
+ * @param args Claim arguments
+ * @returns Transaction object with { kind, to, data, value? }
+ */
+declare function getClaimLegacyFeesTransaction(publicClient: PublicClient, args: LegacyClaimArgs): Promise<LegacyClaimTx>;
+/**
+ * Estimate claimable Uniswap V3 LP fees for a legacy position on Base.
+ *
+ * Reads ownerOf(positionId) and simulates collect() to get the claimable amounts.
+ *
+ * @param publicClient Viem public client for Base
+ * @param opts Options with chainId and positionId
+ * @returns Claimable fees with positionOwner, token0, token1, amount0, amount1
+ */
+declare function getLegacyClaimableFees(publicClient: PublicClient, opts: {
+    chainId: number;
+    positionId: bigint;
+}): Promise<LegacyClaimableFees>;
 
-export { EXPECTED_MERKLE_ROOT, LEGACY_FEE_CLAIMS_ADDRESS, LegacyFeeClaims, type MerkleProofResult, type TokenCreatorEntry, getInitializeTokenCreatorTransaction, getTokenCreatorMerkleProof, getTokenCreatorTransferTransaction, getUpdateTokenCreatorTransaction, parseTokenCreatorCSV };
+export { BASE_CHAIN_ID, CLANKER_FACTORIES_BASE, type ClaimLegacyCreatorFeesInput, ClankerClaimRewardsAbi, ClankerTokenDeployerAbi, EXPECTED_MERKLE_ROOT, LEGACY_FACTORIES, LEGACY_FEE_CLAIMS_ADDRESS, type LegacyClaimArgs, type LegacyClaimFeesInput, type LegacyClaimFeesTransaction, type LegacyClaimTransactionConfig, type LegacyClaimTx, type LegacyClaimTxKind, type LegacyClaimableFees, LegacyCreatorFees, LegacyFeeClaims, type LegacyTokenType, type LegacyVersion, LockerCollectFeesAbi, type LockerParams, type MerkleProofResult, MetaLockerCollectFeesAbi, NonfungiblePositionManagerCollectAbi, NonfungiblePositionManagerOwnerOfAbi, NonfungiblePositionManagerPositionsAbi, type TokenCreatorEntry, UNISWAP_V3_BASE, getClaimLegacyCreatorFeesTransaction, getClaimLegacyFeesTransaction, getInitializeTokenCreatorTransaction, getLegacyClaimableFees, getTokenCreatorMerkleProof, getTokenCreatorTransferTransaction, getUpdateTokenCreatorTransaction, parseTokenCreatorCSV };