clanker-sdk 4.2.8 → 4.2.10

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 };