@flaunch/sdk 0.4.0 → 0.4.2

package/dist/index.esm.js

@@ -6921,9 +6921,22 @@ const FlaunchPositionManagerAbi = [
     { stateMutability: "payable", type: "receive" },
 ];
 
+// List of public IPFS gateways to cycle through
+const IPFS_GATEWAYS = [
+    "https://gateway.pinata.cloud/ipfs/",
+    "https://ipfs.io/ipfs/",
+    "https://dweb.link/ipfs/",
+];
+// Counter to track the current gateway index
+let currentGatewayIndex = 0;
 const resolveIPFS = (value) => {
     if (value.startsWith("ipfs://")) {
-        return `https://gateway.pinata.cloud/ipfs/${value.slice(7)}`;
+        const cid = value.slice(7);
+        // Get the next gateway and increment the counter
+        const gateway = IPFS_GATEWAYS[currentGatewayIndex];
+        // Update the counter, cycling back to 0 when we reach the end
+        currentGatewayIndex = (currentGatewayIndex + 1) % IPFS_GATEWAYS.length;
+        return `${gateway}${cid}`;
     }
     return value;
 };
@@ -10196,6 +10209,16 @@ class ReadFlaunch {
             _tokenId: tokenId,
         });
     }
+    /**
+     * Gets the memecoin address for a given token ID
+     * @param tokenId - The ID of the token
+     * @returns Promise<Address> - The address of the memecoin
+     */
+    memecoin(tokenId) {
+        return this.contract.read("memecoin", {
+            _tokenId: tokenId,
+        });
+    }
 }
 
 const MemecoinAbi = [
@@ -16318,8 +16341,470 @@ const RevenueManagerAbi = [
     { stateMutability: "payable", type: "receive" },
 ];
 
+const MulticallAbi = [
+    {
+        inputs: [
+            {
+                components: [
+                    {
+                        internalType: "address",
+                        name: "target",
+                        type: "address",
+                    },
+                    {
+                        internalType: "bytes",
+                        name: "callData",
+                        type: "bytes",
+                    },
+                ],
+                internalType: "struct Multicall3.Call[]",
+                name: "calls",
+                type: "tuple[]",
+            },
+        ],
+        name: "aggregate",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "blockNumber",
+                type: "uint256",
+            },
+            {
+                internalType: "bytes[]",
+                name: "returnData",
+                type: "bytes[]",
+            },
+        ],
+        stateMutability: "payable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                components: [
+                    {
+                        internalType: "address",
+                        name: "target",
+                        type: "address",
+                    },
+                    {
+                        internalType: "bool",
+                        name: "allowFailure",
+                        type: "bool",
+                    },
+                    {
+                        internalType: "bytes",
+                        name: "callData",
+                        type: "bytes",
+                    },
+                ],
+                internalType: "struct Multicall3.Call3[]",
+                name: "calls",
+                type: "tuple[]",
+            },
+        ],
+        name: "aggregate3",
+        outputs: [
+            {
+                components: [
+                    {
+                        internalType: "bool",
+                        name: "success",
+                        type: "bool",
+                    },
+                    {
+                        internalType: "bytes",
+                        name: "returnData",
+                        type: "bytes",
+                    },
+                ],
+                internalType: "struct Multicall3.Result[]",
+                name: "returnData",
+                type: "tuple[]",
+            },
+        ],
+        stateMutability: "payable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                components: [
+                    {
+                        internalType: "address",
+                        name: "target",
+                        type: "address",
+                    },
+                    {
+                        internalType: "bool",
+                        name: "allowFailure",
+                        type: "bool",
+                    },
+                    {
+                        internalType: "uint256",
+                        name: "value",
+                        type: "uint256",
+                    },
+                    {
+                        internalType: "bytes",
+                        name: "callData",
+                        type: "bytes",
+                    },
+                ],
+                internalType: "struct Multicall3.Call3Value[]",
+                name: "calls",
+                type: "tuple[]",
+            },
+        ],
+        name: "aggregate3Value",
+        outputs: [
+            {
+                components: [
+                    {
+                        internalType: "bool",
+                        name: "success",
+                        type: "bool",
+                    },
+                    {
+                        internalType: "bytes",
+                        name: "returnData",
+                        type: "bytes",
+                    },
+                ],
+                internalType: "struct Multicall3.Result[]",
+                name: "returnData",
+                type: "tuple[]",
+            },
+        ],
+        stateMutability: "payable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                components: [
+                    {
+                        internalType: "address",
+                        name: "target",
+                        type: "address",
+                    },
+                    {
+                        internalType: "bytes",
+                        name: "callData",
+                        type: "bytes",
+                    },
+                ],
+                internalType: "struct Multicall3.Call[]",
+                name: "calls",
+                type: "tuple[]",
+            },
+        ],
+        name: "blockAndAggregate",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "blockNumber",
+                type: "uint256",
+            },
+            {
+                internalType: "bytes32",
+                name: "blockHash",
+                type: "bytes32",
+            },
+            {
+                components: [
+                    {
+                        internalType: "bool",
+                        name: "success",
+                        type: "bool",
+                    },
+                    {
+                        internalType: "bytes",
+                        name: "returnData",
+                        type: "bytes",
+                    },
+                ],
+                internalType: "struct Multicall3.Result[]",
+                name: "returnData",
+                type: "tuple[]",
+            },
+        ],
+        stateMutability: "payable",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getBasefee",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "basefee",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "uint256",
+                name: "blockNumber",
+                type: "uint256",
+            },
+        ],
+        name: "getBlockHash",
+        outputs: [
+            {
+                internalType: "bytes32",
+                name: "blockHash",
+                type: "bytes32",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getBlockNumber",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "blockNumber",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getChainId",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "chainid",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getCurrentBlockCoinbase",
+        outputs: [
+            {
+                internalType: "address",
+                name: "coinbase",
+                type: "address",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getCurrentBlockDifficulty",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "difficulty",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getCurrentBlockGasLimit",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "gaslimit",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getCurrentBlockTimestamp",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "timestamp",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "addr",
+                type: "address",
+            },
+        ],
+        name: "getEthBalance",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "balance",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getLastBlockHash",
+        outputs: [
+            {
+                internalType: "bytes32",
+                name: "blockHash",
+                type: "bytes32",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "bool",
+                name: "requireSuccess",
+                type: "bool",
+            },
+            {
+                components: [
+                    {
+                        internalType: "address",
+                        name: "target",
+                        type: "address",
+                    },
+                    {
+                        internalType: "bytes",
+                        name: "callData",
+                        type: "bytes",
+                    },
+                ],
+                internalType: "struct Multicall3.Call[]",
+                name: "calls",
+                type: "tuple[]",
+            },
+        ],
+        name: "tryAggregate",
+        outputs: [
+            {
+                components: [
+                    {
+                        internalType: "bool",
+                        name: "success",
+                        type: "bool",
+                    },
+                    {
+                        internalType: "bytes",
+                        name: "returnData",
+                        type: "bytes",
+                    },
+                ],
+                internalType: "struct Multicall3.Result[]",
+                name: "returnData",
+                type: "tuple[]",
+            },
+        ],
+        stateMutability: "payable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "bool",
+                name: "requireSuccess",
+                type: "bool",
+            },
+            {
+                components: [
+                    {
+                        internalType: "address",
+                        name: "target",
+                        type: "address",
+                    },
+                    {
+                        internalType: "bytes",
+                        name: "callData",
+                        type: "bytes",
+                    },
+                ],
+                internalType: "struct Multicall3.Call[]",
+                name: "calls",
+                type: "tuple[]",
+            },
+        ],
+        name: "tryBlockAndAggregate",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "blockNumber",
+                type: "uint256",
+            },
+            {
+                internalType: "bytes32",
+                name: "blockHash",
+                type: "bytes32",
+            },
+            {
+                components: [
+                    {
+                        internalType: "bool",
+                        name: "success",
+                        type: "bool",
+                    },
+                    {
+                        internalType: "bytes",
+                        name: "returnData",
+                        type: "bytes",
+                    },
+                ],
+                internalType: "struct Multicall3.Result[]",
+                name: "returnData",
+                type: "tuple[]",
+            },
+        ],
+        stateMutability: "payable",
+        type: "function",
+    },
+];
+
+class ReadMulticall {
+    constructor(drift) {
+        // same address across all chains
+        this.address = "0xcA11bde05977b3631167028862bE2a173976CA11";
+        this.contract = drift.contract({
+            abi: MulticallAbi,
+            address: this.address,
+        });
+    }
+    aggregate3(calls) {
+        return this.contract.simulateWrite("aggregate3", {
+            calls: calls.map((call) => ({
+                target: call.target,
+                allowFailure: true,
+                callData: call.callData,
+            })),
+        });
+    }
+}
+
 class ReadRevenueManager {
     constructor(address, drift = createDrift()) {
+        this.drift = drift;
         this.contract = drift.contract({
             abi: RevenueManagerAbi,
             address,
@@ -16342,6 +16827,51 @@ class ReadRevenueManager {
     protocolRecipient() {
         return this.contract.read("protocolRecipient");
     }
+    /**
+     * Gets the total number of tokens managed by the revenue manager
+     * @returns Promise<bigint> - The total count of tokens
+     */
+    async tokensCount() {
+        const nextInternalId = await this.contract.read("nextInternalId");
+        return nextInternalId - 1n;
+    }
+    /**
+     * Gets all tokens created by a specific creator address
+     * @param creator - The address of the creator to query tokens for
+     * @param sortByDesc - Optional boolean to sort tokens in descending order (default: false)
+     * @returns Promise<Array<{flaunch: Address, tokenId: bigint}>> - Array of token objects containing flaunch address and token ID
+     */
+    async allTokensByCreator(creator, sortByDesc = false) {
+        const tokens = await this.contract.read("tokens", {
+            _creator: creator,
+        });
+        if (sortByDesc) {
+            return [...tokens].reverse();
+        }
+        return tokens;
+    }
+    /**
+     * Gets all tokens currently managed by the revenue manager contract
+     * @dev Uses multicall to batch requests for better performance
+     * @param sortByDesc - Optional boolean to sort tokens in descending order (default: false)
+     * @returns Promise<Array<{flaunch: Address, tokenId: bigint}>> - Array of token objects containing flaunch address and token ID
+     */
+    async allTokensInManager(sortByDesc = false) {
+        const count = await this.tokensCount();
+        const multicall = new ReadMulticall(this.drift);
+        let calldatas = Array.from({ length: Number(count) }, (_, i) => this.contract.encodeFunctionData("internalIds", {
+            _internalId: BigInt(i + 1),
+        }));
+        // Reverse the array if sortByDesc is true
+        if (sortByDesc) {
+            calldatas = calldatas.reverse();
+        }
+        const result = await multicall.aggregate3(calldatas.map((calldata) => ({
+            target: this.contract.address,
+            callData: calldata,
+        })));
+        return result.map((r) => this.contract.decodeFunctionReturn("internalIds", r.returnData));
+    }
 }
 class ReadWriteRevenueManager extends ReadRevenueManager {
     constructor(address, drift = createDrift()) {
@@ -17041,6 +17571,7 @@ class ReadFlaunchSDK {
         this.TICK_SPACING = TICK_SPACING;
         this.chainId = chainId;
         this.drift = drift;
+        this.resolveIPFS = resolveIPFS;
         this.readPositionManager = new ReadFlaunchPositionManager(FlaunchPositionManagerAddress[this.chainId], drift);
         this.readPositionManagerV1_1 = new ReadFlaunchPositionManagerV1_1(FlaunchPositionManagerV1_1Address[this.chainId], drift);
         this.readPoolManager = new ReadPoolManager(PoolManagerAddress[this.chainId], drift);
@@ -17082,12 +17613,12 @@ class ReadFlaunchSDK {
         const symbol = await memecoin.symbol();
         const tokenURI = await memecoin.tokenURI();
         // get metadata from tokenURI
-        const metadata = (await axios.get(resolveIPFS(tokenURI))).data;
+        const metadata = (await axios.get(this.resolveIPFS(tokenURI))).data;
         return {
             name,
             symbol,
             description: metadata.description ?? "",
-            image: metadata.image ? resolveIPFS(metadata.image) : "",
+            image: metadata.image ? this.resolveIPFS(metadata.image) : "",
             external_link: metadata.websiteUrl ?? "",
             collaborators: metadata.collaborators ?? [],
             discordUrl: metadata.discordUrl ?? "",
@@ -17095,6 +17626,103 @@ class ReadFlaunchSDK {
             telegramUrl: metadata.telegramUrl ?? "",
         };
     }
+    /**
+     * Retrieves metadata for a given Flaunch coin using its token ID & Flaunch contract address
+     * @param flaunch - The address of the Flaunch contract
+     * @param tokenId - The token ID of the coin
+     * @returns The coin's metadata including name, symbol, description, and social links
+     */
+    async getCoinMetadataFromTokenId(flaunch, tokenId) {
+        const _flaunch = new ReadFlaunch(flaunch, this.drift);
+        const coinAddress = await _flaunch.memecoin(tokenId);
+        return this.getCoinMetadata(coinAddress);
+    }
+    /**
+     * Retrieves metadata for multiple Flaunch coins using their token IDs & Flaunch contract addresses
+     * @param params - An array of objects containing flaunch contract address and token ID
+     * @param batchSize - Optional, the number of ipfs requests to process in each batch
+     * @param batchDelay - Optional, the delay in milliseconds between batches
+     * @returns An array of objects containing coin address, name, symbol, description, and social links
+     */
+    async getCoinMetadataFromTokenIds(params, batchSize = 9, batchDelay = 500) {
+        const multicall = new ReadMulticall(this.drift);
+        // get coin addresses via multicall
+        const coinAddresses_calldata = params.map((p) => this.readFlaunch.contract.encodeFunctionData("memecoin", {
+            _tokenId: p.tokenId,
+        }));
+        const coinAddresses_result = await multicall.aggregate3(coinAddresses_calldata.map((calldata, i) => ({
+            target: params[i].flaunch,
+            callData: calldata,
+        })));
+        const coinAddresses = coinAddresses_result.map((r) => this.readFlaunch.contract.decodeFunctionReturn("memecoin", r.returnData));
+        /// get coin metadata for each coin address via multicall
+        const coinMetadata_calldata = [];
+        // name, symbol, tokenURI for each coin
+        coinAddresses.forEach(() => {
+            coinMetadata_calldata.push(this.drift.adapter.encodeFunctionData({
+                abi: MemecoinAbi,
+                fn: "name",
+            }));
+            coinMetadata_calldata.push(this.drift.adapter.encodeFunctionData({
+                abi: MemecoinAbi,
+                fn: "symbol",
+            }));
+            coinMetadata_calldata.push(this.drift.adapter.encodeFunctionData({
+                abi: MemecoinAbi,
+                fn: "tokenURI",
+            }));
+        });
+        const coinMetadata_result = await multicall.aggregate3(coinMetadata_calldata.map((calldata, i) => ({
+            target: coinAddresses[Math.floor(i / 3)],
+            callData: calldata,
+        })));
+        // First decode all the results
+        const results = [];
+        for (let i = 0; i < coinAddresses.length; i++) {
+            const name = this.drift.adapter.decodeFunctionReturn({
+                abi: MemecoinAbi,
+                fn: "name",
+                data: coinMetadata_result[i * 3].returnData,
+            });
+            const symbol = this.drift.adapter.decodeFunctionReturn({
+                abi: MemecoinAbi,
+                fn: "symbol",
+                data: coinMetadata_result[i * 3 + 1].returnData,
+            });
+            const tokenURI = this.drift.adapter.decodeFunctionReturn({
+                abi: MemecoinAbi,
+                fn: "tokenURI",
+                data: coinMetadata_result[i * 3 + 2].returnData,
+            });
+            results.push({ name, symbol, tokenURI, coinAddress: coinAddresses[i] });
+        }
+        // Process IPFS requests in batches to avoid rate limiting
+        const processedResults = [];
+        for (let i = 0; i < results.length; i += batchSize) {
+            const batch = results.slice(i, i + batchSize);
+            const batchResults = await Promise.all(batch.map(async ({ name, symbol, tokenURI, coinAddress }) => {
+                const metadata = (await axios.get(this.resolveIPFS(tokenURI))).data;
+                return {
+                    coinAddress,
+                    name,
+                    symbol,
+                    description: metadata.description ?? "",
+                    image: metadata.image ? this.resolveIPFS(metadata.image) : "",
+                    external_link: metadata.websiteUrl ?? "",
+                    collaborators: metadata.collaborators ?? [],
+                    discordUrl: metadata.discordUrl ?? "",
+                    twitterUrl: metadata.twitterUrl ?? "",
+                    telegramUrl: metadata.telegramUrl ?? "",
+                };
+            }));
+            processedResults.push(...batchResults);
+            // Add a small delay between batches to avoid rate limiting
+            if (i + batchSize < results.length) {
+                await new Promise((resolve) => setTimeout(resolve, batchDelay));
+            }
+        }
+        return processedResults;
+    }
     /**
      * Watches for pool creation events on V1 contracts
      * @param params - Parameters for watching pool creation
@@ -17456,6 +18084,38 @@ class ReadFlaunchSDK {
         const protocolRecipient = await readRevenueManager.protocolRecipient();
         return readRevenueManager.balances(protocolRecipient);
     }
+    /**
+     * Gets the total number of tokens managed by a revenue manager
+     * @param revenueManagerAddress - The address of the revenue manager
+     * @returns Promise<bigint> - The total count of tokens
+     */
+    async revenueManagerTokensCount(revenueManagerAddress) {
+        const readRevenueManager = new ReadRevenueManager(revenueManagerAddress, this.drift);
+        return readRevenueManager.tokensCount();
+    }
+    /**
+     * Gets all tokens created by a specific creator address
+     * @param params - Parameters for querying tokens by creator
+     * @param params.revenueManagerAddress - The address of the revenue manager
+     * @param params.creator - The address of the creator to query tokens for
+     * @param params.sortByDesc - Whether to sort the tokens by descending order
+     * @returns Promise<Array<{flaunch: Address, tokenId: bigint}>> - Array of token objects containing flaunch address and token ID
+     */
+    async revenueManagerAllTokensByCreator(params) {
+        const readRevenueManager = new ReadRevenueManager(params.revenueManagerAddress, this.drift);
+        return readRevenueManager.allTokensByCreator(params.creator, params.sortByDesc);
+    }
+    /**
+     * Gets all tokens currently managed by a revenue manager
+     * @param params - Parameters for querying tokens in manager
+     * @param params.revenueManagerAddress - The address of the revenue manager
+     * @param params.sortByDesc - Optional boolean to sort tokens in descending order (default: false)
+     * @returns Promise<Array<{flaunch: Address, tokenId: bigint}>> - Array of token objects containing flaunch address and token ID
+     */
+    async revenueManagerAllTokensInManager(params) {
+        const readRevenueManager = new ReadRevenueManager(params.revenueManagerAddress, this.drift);
+        return readRevenueManager.allTokensInManager(params.sortByDesc);
+    }
     /**
      * Gets the pool ID for a given coin
      * @param coinAddress - The address of the coin
@@ -17484,6 +18144,14 @@ class ReadFlaunchSDK {
     flETHIsCurrencyZero(coinAddress) {
         return coinAddress > FLETHAddress[this.chainId];
     }
+    /**
+     * Sets a custom IPFS resolver function
+     * @dev this is used to resolve IPFS hash to a gateway URL
+     * @param resolverFn - Custom function to resolve IPFS URIs
+     */
+    setIPFSResolver(resolverFn) {
+        this.resolveIPFS = resolverFn;
+    }
 }
 class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
     constructor(chainId, drift = createDrift()) {