apinow-sdk 0.9.0 → 0.11.0

package/README.md

@@ -1,14 +1,13 @@
 # ApiNow SDK
 
-A TypeScript SDK for interacting with ApiNow endpoints, supporting Ethereum (including Base), and Solana chains. Designed to work in Node.js, browsers, and edge environments like Cloudflare Workers.
+A TypeScript SDK for interacting with ApiNow endpoints, supporting Ethereum and Base chains. Designed to work in Node.js, browsers, and edge environments like Cloudflare Workers.
 
 ## Features
 
-- Multi-chain support (Ethereum, Base, Solana)
-- Native and Token transfers (ERC20 on ETH/Base, SPL on Solana)
+- Multi-chain support (Ethereum, Base)
+- Native and ERC20 token transfers
 - Environment Agnostic: Uses global `fetch` for broad compatibility.
 - Optional RPC URL: Uses public RPCs by default, allows override.
-- Fast mode for quicker transaction processing (skips confirmation wait).
 - TypeScript types for better development experience.
 
 ## Installation
@@ -27,20 +26,21 @@ yarn add apinow-sdk
 import apiNow from 'apinow-sdk';
 
 const ENDPOINT_URL = 'https://apinow.fun/api/endpoints/your-endpoint';
-const YOUR_PRIVATE_KEY = '0x...'; // Or Solana base58 private key
+const YOUR_WALLET_PRIVATE_KEY = '0x...'; 
 
 // 1. Get endpoint info (payment details)
 const info = await apiNow.info(ENDPOINT_URL);
 // info will contain: { requiredAmount, walletAddress, httpMethod, tokenAddress, chain }
+// Note: chain will be 'eth' or 'base'
 console.log('Payment required:', info);
 
 // 2. Send payment and get the API response in one step
 try {
   const response = await apiNow.infoBuyResponse(
     ENDPOINT_URL,
-    YOUR_PRIVATE_KEY
+    YOUR_WALLET_PRIVATE_KEY
     // Optional: Add RPC URL override here if needed
-    // Optional: Add options like { fastMode: true } here
+    // Optional: Add options like { fastMode: true } here (Note: fastMode currently has no effect)
   );
   console.log('API Response:', response);
 } catch (error) {
@@ -50,64 +50,61 @@ try {
 
 ### Providing a Custom RPC URL
 
-If you need to use a specific RPC node:
+If you need to use a specific RPC node (e.g., for Base):
 
 ```typescript
-const CUSTOM_RPC_URL = 'https://your-custom-node.com';
+const CUSTOM_RPC_URL = 'https://mainnet.base.org';
 
 const response = await apiNow.infoBuyResponse(
   ENDPOINT_URL,
-  YOUR_PRIVATE_KEY,
+  YOUR_WALLET_PRIVATE_KEY,
   CUSTOM_RPC_URL // Provide the RPC URL here
 );
 ```
 
 ### Fast Mode
 
-Fast mode skips waiting for transaction confirmation. This provides faster responses but relies on the transaction being accepted by the network (mempool/leader inclusion).
+*Note: `fastMode` is currently included for potential future use but does not affect Ethereum/Base transaction confirmation behavior in this version.* 
 
 ```typescript
 const response = await apiNow.infoBuyResponse(
   ENDPOINT_URL,
-  YOUR_PRIVATE_KEY,
+  YOUR_WALLET_PRIVATE_KEY,
   undefined, // Use default RPC
-  { fastMode: true } // Enable fast mode
+  { fastMode: true } // Option included, but no effect yet
 );
 ```
 
 ### Manual Payment (Separate Steps)
 
-You can also perform the payment manually if needed.
-
 ```typescript
 import apiNow from 'apinow-sdk';
-import { ethers } from 'ethers'; // For amount conversion if needed
+import { ethers } from 'ethers';
 
 const ENDPOINT_URL = 'https://apinow.fun/api/endpoints/your-endpoint';
-const YOUR_PRIVATE_KEY = '0x...';
+const YOUR_WALLET_PRIVATE_KEY = '0x...';
 const YOUR_CUSTOM_RPC_URL = 'https://your-node.com'; // Optional
 
 // 1. Get Info
 const info = await apiNow.info(ENDPOINT_URL);
 const { requiredAmount, walletAddress, chain, tokenAddress } = info;
 
-// Convert requiredAmount (string) to bigint (smallest unit: wei/lamports)
+// Convert requiredAmount (string) to bigint (wei)
 const amountBigInt = BigInt(requiredAmount);
 
 // 2. Send Payment
 const txHash = await apiNow.buy(
   walletAddress,
   amountBigInt,
-  YOUR_PRIVATE_KEY,
-  chain, // Specify the chain from info
+  YOUR_WALLET_PRIVATE_KEY,
+  chain, // 'eth' or 'base'
   YOUR_CUSTOM_RPC_URL, // Optional: override RPC
-  tokenAddress, // Optional: specify token if required by endpoint
-  false // Optional: fastMode (defaults to false)
+  tokenAddress // Optional: specify ERC20 token if required
+  // fastMode param exists but is unused by handler
 );
 console.log(`Payment sent: ${txHash}`);
 
-// 3. Get API Response (after waiting for confirmation if not fastMode)
-// Add a delay here if needed
+// 3. Get API Response (add delay as needed)
 await new Promise(resolve => setTimeout(resolve, 5000)); // Example 5s delay
 
 const apiResponse = await apiNow.txResponse(
@@ -123,14 +120,15 @@ console.log('API Response:', apiResponse);
 
 Gets payment requirement information about an ApiNow endpoint.
 
-### `buy(walletAddress: string, amount: bigint, pkey: string, chain: 'eth' | 'sol' | 'base', rpcUrl?: string, tokenAddress?: string, fastMode?: boolean): Promise<string>`
+### `buy(walletAddress: string, amount: bigint, userWalletPrivateKey: string, chain: 'eth' | 'base', rpcUrl?: string, tokenAddress?: string, fastMode?: boolean): Promise<string>`
 
 Sends the required payment transaction to the specified address.
-- `amount`: The required amount in the smallest unit (wei for ETH/Base, lamports for SOL).
-- `chain`: The blockchain target ('eth', 'sol', 'base').
+- `amount`: The required amount in the smallest unit (wei).
+- `userWalletPrivateKey`: The private key of the wallet sending the funds.
+- `chain`: The blockchain target ('eth' or 'base').
 - `rpcUrl` (Optional): Overrides the default public RPC URL.
-- `tokenAddress` (Optional): The contract address if paying with an ERC20/SPL token.
-- `fastMode` (Optional): If true, returns the transaction hash immediately without waiting for confirmation.
+- `tokenAddress` (Optional): The contract address if paying with an ERC20 token.
+- `fastMode` (Optional): Parameter exists but currently has no effect.
 
 Returns the transaction hash.
 
@@ -138,15 +136,16 @@ Returns the transaction hash.
 
 Fetches the final API response from the endpoint after a successful payment.
 - `txHash`: The hash of the payment transaction.
-- `opts` (Optional): Options like `{ method: 'POST', data: {...} }` to be passed to the underlying endpoint API call if needed (usually configured by the endpoint itself).
+- `opts` (Optional): Options like `{ method: 'POST', data: {...} }`.
 
 Returns the endpoint's API response.
 
-### `infoBuyResponse(endpoint: string, pkey: string, rpcUrl?: string, opts?: TxResponseOptions & { fastMode?: boolean }): Promise<any>`
+### `infoBuyResponse(endpoint: string, userWalletPrivateKey: string, rpcUrl?: string, opts?: TxResponseOptions & { fastMode?: boolean }): Promise<any>`
 
-Combines `info`, `buy`, and `txResponse` into a single call for convenience.
+Combines `info`, `buy`, and `txResponse` into a single call.
+- `userWalletPrivateKey`: The private key of the wallet sending the funds.
 - `rpcUrl` (Optional): Overrides the default public RPC URL for the payment.
-- `opts` (Optional): Contains `fastMode` boolean and any `TxResponseOptions`.
+- `opts` (Optional): Contains `fastMode` boolean (currently no effect) and any `TxResponseOptions`.
 
 Returns the final API response.
 
@@ -155,16 +154,16 @@ Returns the final API response.
 ```typescript
 // Defined in the SDK
 interface InfoResponse {
-  requiredAmount: string; // Amount in smallest unit (string)
+  requiredAmount: string; // Amount in wei (string)
   walletAddress: string;
-  httpMethod: string; // Usually GET or POST for txResponse
-  tokenAddress?: string;
-  chain: 'eth' | 'sol' | 'base';
+  httpMethod: string; 
+  tokenAddress?: string; // ERC20 address
+  chain: 'eth' | 'base';
 }
 
 interface TxResponseOptions {
-  method?: string; // HTTP method for txResponse call
-  data?: any;      // Body data for txResponse call
+  method?: string; 
+  data?: any;      
 }
 ```
 
@@ -172,7 +171,6 @@ interface TxResponseOptions {
 
 - **Ethereum:** `https://rpc.ankr.com/eth`
 - **Base:** `https://mainnet.base.org`
-- **Solana:** `https://api.mainnet-beta.solana.com`
 
 You can override these by providing the `rpcUrl` parameter to `buy` or `infoBuyResponse`.
 

package/dist/index.d.ts

@@ -7,17 +7,14 @@ interface InfoResponse {
     walletAddress: string;
     httpMethod: string;
     tokenAddress?: string;
-    chain: 'eth' | 'sol' | 'base';
+    chain: 'eth' | 'base';
 }
 declare class ApiNow {
     private handlers;
     info(endpoint: string): Promise<InfoResponse>;
-    buy(walletAddress: string, amount: bigint, pkey: string, chain: 'eth' | 'sol' | 'base', // Chain is now required to choose handler
-    rpcUrl?: string, // Optional RPC URL
-    tokenAddress?: string, fastMode?: boolean): Promise<string>;
+    buy(walletAddress: string, amount: bigint, userWalletPrivateKey: string, chain: 'eth' | 'base', rpcUrl?: string, tokenAddress?: string, fastMode?: boolean): Promise<string>;
     txResponse(endpoint: string, txHash: string, opts?: TxResponseOptions): Promise<any>;
-    infoBuyResponse(endpoint: string, pkey: string, rpcUrl?: string, // Optional RPC URL
-    opts?: TxResponseOptions & {
+    infoBuyResponse(endpoint: string, userWalletPrivateKey: string, rpcUrl?: string, opts?: TxResponseOptions & {
         fastMode?: boolean;
     }): Promise<any>;
 }

package/dist/index.js

@@ -1,12 +1,8 @@
 import { ethers, Wallet, isAddress } from 'ethers';
-import { Connection, PublicKey, Transaction, SystemProgram, Keypair, ComputeBudgetProgram } from '@solana/web3.js';
-import { createTransferInstruction, getAssociatedTokenAddress } from '@solana/spl-token';
-import bs58 from 'bs58';
 // Default RPC URLs
-const DEFAULT_ETH_RPC = 'https://rpc.ankr.com/eth'; // Example public RPC
-const DEFAULT_SOL_RPC = 'https://api.mainnet-beta.solana.com'; // Example public RPC
-const DEFAULT_BASE_RPC = 'https://mainnet.base.org'; // Example public RPC
-// --- Helper function for fetch ---
+const DEFAULT_ETH_RPC = 'https://rpc.ankr.com/eth';
+const DEFAULT_BASE_RPC = 'https://mainnet.base.org';
+// --- Helper function for fetch (Keep this) ---
 async function fetchJson(url, options) {
     const response = await fetch(url, options);
     if (!response.ok) {
@@ -15,7 +11,7 @@ async function fetchJson(url, options) {
     }
     return response.json();
 }
-// --- Helper function for RPC calls ---
+// --- Helper function for RPC calls (Keep this) ---
 async function sendJsonRpc(rpcUrl, method, params) {
     const response = await fetch(rpcUrl, {
         method: 'POST',
@@ -40,53 +36,46 @@ async function sendJsonRpc(rpcUrl, method, params) {
     return jsonResponse.result;
 }
 class EthereumHandler {
-    async buy(walletAddress, amount, pkey, rpcUrl, tokenAddress, fastMode // Keep param for API consistency, but might not affect logic much now
-    ) {
-        const rpc = rpcUrl || (rpcUrl && rpcUrl.includes('base') ? DEFAULT_BASE_RPC : DEFAULT_ETH_RPC); // Determine default based on presence/content of rpcUrl or use general ETH
+    async buy(walletAddress, amount, userWalletPrivateKey, rpcUrl, tokenAddress) {
+        const rpc = rpcUrl || (rpcUrl && rpcUrl.includes('base') ? DEFAULT_BASE_RPC : DEFAULT_ETH_RPC);
         if (!walletAddress || !isAddress(walletAddress)) {
             throw new Error('Invalid recipient wallet address');
         }
-        const wallet = new Wallet(pkey); // Create wallet without provider initially
+        const wallet = new Wallet(userWalletPrivateKey);
         const senderAddress = wallet.address;
         try {
-            // Get nonce manually
             const nonce = await sendJsonRpc(rpc, 'eth_getTransactionCount', [senderAddress, 'latest']);
-            // Get gas price suggestion (EIP-1559)
-            const feeData = await sendJsonRpc(rpc, 'eth_gasPrice', []); // Using legacy gasPrice for simplicity, could fetch EIP-1559 fees
+            const feeData = await sendJsonRpc(rpc, 'eth_gasPrice', []);
             let txRequest;
             if (tokenAddress) {
                 if (!isAddress(tokenAddress)) {
                     throw new Error('Invalid token address');
                 }
-                // ERC20 Transfer
                 const abi = ["function transfer(address to, uint256 amount)"];
                 const iface = new ethers.Interface(abi);
                 const data = iface.encodeFunctionData("transfer", [walletAddress, amount]);
                 txRequest = {
                     to: tokenAddress,
                     nonce: parseInt(nonce, 16),
-                    gasPrice: feeData, // Use fetched gas price
-                    // Estimate gas manually if needed, or use a standard limit
-                    gasLimit: 100000, // Adjust as necessary for ERC20 transfers
+                    gasPrice: feeData,
+                    gasLimit: 100000,
                     data: data,
-                    chainId: (await sendJsonRpc(rpc, 'eth_chainId', [])), // Fetch chainId
+                    chainId: (await sendJsonRpc(rpc, 'eth_chainId', [])),
                 };
             }
             else {
-                // Native ETH/Base Transfer
                 txRequest = {
                     to: walletAddress,
                     value: amount,
                     nonce: parseInt(nonce, 16),
-                    gasPrice: feeData, // Use fetched gas price
-                    gasLimit: 21000, // Standard limit for native transfers
-                    chainId: (await sendJsonRpc(rpc, 'eth_chainId', [])), // Fetch chainId
+                    gasPrice: feeData,
+                    gasLimit: 21000,
+                    chainId: (await sendJsonRpc(rpc, 'eth_chainId', [])),
                 };
             }
             const signedTx = await wallet.signTransaction(txRequest);
             const txHash = await sendJsonRpc(rpc, 'eth_sendRawTransaction', [signedTx]);
-            // TODO: Optionally wait for confirmation if fastMode is false
-            // This would involve polling eth_getTransactionReceipt
+            console.log(`Transaction sent: ${txHash}. Confirmation check not implemented.`);
             return txHash;
         }
         catch (error) {
@@ -95,125 +84,13 @@ class EthereumHandler {
         }
     }
 }
-class SolanaHandler {
-    // Keep using Connection for some helpers, but sendRawTransaction manually
-    async getConnection(rpcUrl) {
-        const rpc = rpcUrl || DEFAULT_SOL_RPC;
-        return new Connection(rpc, {
-            commitment: 'processed',
-            confirmTransactionInitialTimeout: 10000 // Used by getMint etc.
-        });
-    }
-    async buy(walletAddress, amount, pkey, rpcUrl, tokenAddress, fastMode) {
-        const rpc = rpcUrl || DEFAULT_SOL_RPC;
-        const connection = await this.getConnection(rpc); // Still useful for some reads
-        try {
-            const recipientPubkey = new PublicKey(walletAddress);
-            const senderKeypair = Keypair.fromSecretKey(bs58.decode(pkey));
-            const transaction = new Transaction();
-            // Add priority fee instruction
-            transaction.add(ComputeBudgetProgram.setComputeUnitPrice({
-                microLamports: 50000 // Example fee, adjust as needed
-            }));
-            // Add compute unit limit if necessary, e.g., for token transfers
-            transaction.add(ComputeBudgetProgram.setComputeUnitLimit({
-                units: tokenAddress ? 200000 : 50000 // Higher limit for token ops
-            }));
-            if (tokenAddress) {
-                const mint = new PublicKey(tokenAddress);
-                // Use connection helpers for these reads
-                const senderATA = await getAssociatedTokenAddress(mint, senderKeypair.publicKey);
-                const recipientATA = await getAssociatedTokenAddress(mint, recipientPubkey);
-                // Check if recipient ATA exists, if not, add instruction to create it
-                const recipientATAInfo = await connection.getAccountInfo(recipientATA);
-                if (!recipientATAInfo) {
-                    // This part needs @solana/spl-token's createAssociatedTokenAccountInstruction
-                    // Import: import { createAssociatedTokenAccountInstruction } from '@solana/spl-token';
-                    // transaction.add(
-                    //     createAssociatedTokenAccountInstruction(
-                    //         senderKeypair.publicKey, // Payer
-                    //         recipientATA,
-                    //         recipientPubkey,
-                    //         mint
-                    //     )
-                    // );
-                    console.warn("Recipient Associated Token Account does not exist. Auto-creation commented out. Ensure recipient has the ATA.");
-                    // For now, we'll proceed assuming it exists or will be created elsewhere.
-                    // Production code should handle this creation properly.
-                }
-                transaction.add(createTransferInstruction(senderATA, recipientATA, senderKeypair.publicKey, Number(amount) // SPL transfer amount expects number
-                ));
-            }
-            else {
-                // SOL transfer
-                transaction.add(SystemProgram.transfer({
-                    fromPubkey: senderKeypair.publicKey,
-                    toPubkey: recipientPubkey,
-                    lamports: Number(amount) // SystemProgram.transfer expects number
-                }));
-            }
-            // Get blockhash manually
-            const { blockhash, lastValidBlockHeight } = await sendJsonRpc(rpc, 'getLatestBlockhash', [{ 'commitment': 'processed' }]);
-            transaction.recentBlockhash = blockhash;
-            transaction.feePayer = senderKeypair.publicKey;
-            transaction.sign(senderKeypair);
-            const rawTx = transaction.serialize();
-            const base64Tx = Buffer.from(rawTx).toString('base64');
-            // Send transaction manually via RPC
-            const signature = await sendJsonRpc(rpc, 'sendTransaction', [
-                base64Tx,
-                {
-                    encoding: 'base64',
-                    skipPreflight: false, // Usually false
-                    preflightCommitment: 'processed',
-                    maxRetries: 2
-                }
-            ]);
-            // Optionally confirm transaction if not in fastMode
-            if (!fastMode) {
-                console.log('Waiting for Solana confirmation (up to 30s)... Signature:', signature);
-                try {
-                    // Ensure blockhash is defined before confirming
-                    if (!transaction.recentBlockhash) {
-                        throw new Error("Transaction recentBlockhash is missing, cannot confirm.");
-                    }
-                    await connection.confirmTransaction({
-                        signature,
-                        blockhash: transaction.recentBlockhash, // Now confirmed non-undefined
-                        lastValidBlockHeight // Use the height we got
-                    }, 'processed'); // or 'confirmed'/'finalized'
-                    console.log('Solana transaction confirmed!');
-                }
-                catch (confirmError) {
-                    console.error(`Solana confirmation failed for ${signature}:`, confirmError);
-                    // Don't necessarily throw here, tx might still succeed eventually
-                    // Consider returning signature but warning about confirmation failure
-                }
-            }
-            return signature;
-        }
-        catch (error) {
-            console.error('Detailed SOL error:', error);
-            // Try to provide more specific error info if possible
-            if (error instanceof Error && error.message.includes('AccountNotFound')) {
-                throw new Error(`Solana transaction failed: Source token account might not exist or have funds. ${error.message}`);
-            }
-            if (error instanceof Error && error.message.includes('Invalid private key')) {
-                throw new Error(`Solana transaction failed: Invalid private key provided. ${error.message}`);
-            }
-            throw new Error(`Solana transaction failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-}
 class ApiNow {
     constructor() {
         this.handlers = {
             eth: new EthereumHandler(),
-            sol: new SolanaHandler(),
-            base: new EthereumHandler() // Base uses Ethereum handler
+            base: new EthereumHandler()
         };
     }
-    // Use helper function
     async info(endpoint) {
         if (!endpoint || typeof endpoint !== 'string') {
             throw new Error('Invalid endpoint URL');
@@ -226,10 +103,7 @@ class ApiNow {
             throw new Error(`Could not get endpoint info: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
-    // Updated to accept optional rpcUrl
-    async buy(walletAddress, amount, pkey, chain, // Chain is now required to choose handler
-    rpcUrl, // Optional RPC URL
-    tokenAddress, fastMode) {
+    async buy(walletAddress, amount, userWalletPrivateKey, chain, rpcUrl, tokenAddress, fastMode) {
         const handler = this.handlers[chain];
         if (!handler) {
             throw new Error(`Unsupported chain: ${chain}`);
@@ -237,10 +111,8 @@ class ApiNow {
         if (amount <= 0n) {
             throw new Error('Amount must be positive.');
         }
-        // Pass rpcUrl to the handler
-        return handler.buy(walletAddress, amount, pkey, rpcUrl, tokenAddress, fastMode);
+        return handler.buy(walletAddress, amount, userWalletPrivateKey, rpcUrl, tokenAddress);
     }
-    // Use helper function
     async txResponse(endpoint, txHash, opts = {}) {
         if (!endpoint || typeof endpoint !== 'string') {
             throw new Error('Invalid endpoint URL');
@@ -249,12 +121,11 @@ class ApiNow {
             throw new Error('Invalid transaction hash');
         }
         const url = new URL(endpoint);
-        // Append txHash respecting existing query params
         url.searchParams.append('txHash', txHash);
         try {
             return await fetchJson(url.toString(), {
-                method: opts.method || 'GET', // Default to GET if not specified
-                headers: { 'Content-Type': 'application/json' }, // Assume JSON body if data exists
+                method: opts.method || 'GET',
+                headers: { 'Content-Type': 'application/json' },
                 body: opts.data ? JSON.stringify(opts.data) : undefined
             });
         }
@@ -263,21 +134,16 @@ class ApiNow {
             throw new Error(`Could not get transaction response: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
-    // Updated to accept optional rpcUrl
-    async infoBuyResponse(endpoint, pkey, rpcUrl, // Optional RPC URL
-    opts = {}) {
+    async infoBuyResponse(endpoint, userWalletPrivateKey, rpcUrl, opts = {}) {
         console.log(`Starting infoBuyResponse for endpoint: ${endpoint}`);
-        // 1. Get Info
         const info = await this.info(endpoint);
         console.log("Received info:", info);
         const { requiredAmount, walletAddress, chain, tokenAddress } = info;
         if (!chain || !this.handlers[chain]) {
             throw new Error(`Unsupported chain specified by endpoint: ${chain}`);
         }
-        // Convert required amount string (assuming decimals handled by endpoint info) to bigint
         let amountBigInt;
         try {
-            // Assume requiredAmount is in native smallest units (wei, lamports)
             amountBigInt = BigInt(requiredAmount);
             if (amountBigInt <= 0n) {
                 throw new Error('Required amount must be positive.');
@@ -287,18 +153,13 @@ class ApiNow {
             throw new Error(`Invalid requiredAmount format: ${requiredAmount}`);
         }
         console.log(`Attempting payment: Chain=${chain}, To=${walletAddress}, Amount=${amountBigInt.toString()}, Token=${tokenAddress || 'Native'}`);
-        // 2. Perform Buy (Payment)
-        const txHash = await this.buy(walletAddress, amountBigInt, pkey, chain, // Pass the chain from info
-        rpcUrl, // Pass optional rpcUrl
-        tokenAddress, opts.fastMode);
+        const txHash = await this.buy(walletAddress, amountBigInt, userWalletPrivateKey, chain, rpcUrl, tokenAddress, opts.fastMode);
         console.log(`Transaction sent: ${txHash}`);
-        // 3. Get Tx Response
-        // Add a small delay before fetching the response, especially for non-fast mode
         if (!opts.fastMode) {
-            await new Promise(resolve => setTimeout(resolve, 3000)); // 3-second delay
+            await new Promise(resolve => setTimeout(resolve, 3000));
         }
         else {
-            await new Promise(resolve => setTimeout(resolve, 500)); // Shorter delay for fast mode
+            await new Promise(resolve => setTimeout(resolve, 500));
         }
         console.log(`Fetching response for tx: ${txHash}`);
         return this.txResponse(endpoint, txHash, opts);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apinow-sdk",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "ApiNow SDK · The endpoint vending machine",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -21,8 +21,6 @@
   "author": "ApiNow.fun",
   "license": "MIT",
   "dependencies": {
-    "@solana/spl-token": "^0.4.12",
-    "@solana/web3.js": "^1.98.0",
     "bs58": "^6.0.0",
     "ethers": "^6.13.5"
   },