apinow-sdk 0.2.0 → 0.4.0

package/README.md

@@ -1,6 +1,13 @@
 # ApiNow SDK
 
-The endpoint vending machine - SDK for interacting with ApiNow endpoints. This is the official SDK for [ApiNow.fun](https://apinow.fun).
+A TypeScript SDK for interacting with ApiNow endpoints, supporting Ethereum (including Base), and Solana chains.
+
+## Features
+
+- Multi-chain support (Ethereum, Base, Solana)
+- Token transfers (ERC20 on ETH/Base, SPL on Solana)
+- Fast mode for quicker transaction processing
+- TypeScript types for better development experience
 
 ## Installation
 
@@ -8,78 +15,128 @@ The endpoint vending machine - SDK for interacting with ApiNow endpoints. This i
 npm install apinow-sdk
 ```
 
-## Quick Start
+## Usage
 
-```ts
+### Basic Example
+
+```typescript
 import apiNow from 'apinow-sdk';
 
-// One-shot purchase and response
+// Get endpoint info
+const info = await apiNow.info('https://apinow.fun/api/endpoints/your-endpoint');
+
+// Send payment and get response
 const response = await apiNow.infoBuyResponse(
-  'https://apinow.fun/api/endpoints/my-endpoint',
-  '0x123...private-key',
-  'https://eth-mainnet.g.alchemy.com/v2/YOUR-API-KEY'
+  'https://apinow.fun/api/endpoints/your-endpoint',
+  'YOUR_PRIVATE_KEY',
+  'YOUR_RPC_URL'
 );
 ```
 
-## API Reference
+### Fast Mode
 
-### info(endpoint)
-Fetches endpoint metadata like required ETH amount and wallet address.
+Fast mode skips transaction confirmation and only waits for the transaction to be in the mempool. This provides much faster responses but slightly less security:
 
-```ts
-const info = await apiNow.info('https://apinow.fun/api/endpoints/my-endpoint');
-// Returns: { 
-//   requiredAmount: "0.1",
-//   walletAddress: "0x123...", 
-//   httpMethod: "POST" 
-// }
+```typescript
+const response = await apiNow.infoBuyResponse(
+  'https://apinow.fun/api/endpoints/your-endpoint',
+  'YOUR_PRIVATE_KEY',
+  'YOUR_RPC_URL',
+  { fastMode: true }
+);
 ```
 
-### buy(walletAddress, amount, privateKey, rpcUrl)
-Sends an ETH transaction to purchase endpoint access.
+### Chain-Specific Examples
+
+#### Ethereum/Base
 
-```ts
+```typescript
+// Native ETH/BASE transfer
 const txHash = await apiNow.buy(
-  "0x123...wallet",  // Destination wallet
-  ethers.parseEther("0.1"), // Amount in ETH
-  "0x456...private-key", // Your private key
-  "https://eth-mainnet.g.alchemy.com/v2/YOUR-API-KEY" // RPC URL
+  'RECIPIENT_ADDRESS',
+  ethers.parseEther('0.1'),
+  'YOUR_PRIVATE_KEY',
+  'YOUR_RPC_URL',
+  'eth'
 );
-```
 
-### txResponse(endpoint, txHash, options?)
-Gets the API response using your transaction hash.
-
-```ts
-const response = await apiNow.txResponse(
-  "https://apinow.fun/api/endpoints/my-endpoint",
-  "0x789...txhash",
-  {
-    method: "POST", // Optional, defaults to GET
-    data: { foo: "bar" } // Optional request body
-  }
+// ERC20 token transfer
+const txHash = await apiNow.buy(
+  'RECIPIENT_ADDRESS',
+  ethers.parseUnits('100', 18), // Use appropriate decimals
+  'YOUR_PRIVATE_KEY',
+  'YOUR_RPC_URL',
+  'eth',
+  'TOKEN_ADDRESS'
 );
 ```
 
-### infoBuyResponse(endpoint, privateKey, rpcUrl, options?)
-Combines all steps: fetches info, sends payment, and gets response.
+#### Solana
 
-```ts
-// Complete example with all parameters
-const response = await apiNow.infoBuyResponse(
-  "https://apinow.fun/api/endpoints/my-endpoint",
-  "0x123...private-key",
-  "https://eth-mainnet.g.alchemy.com/v2/YOUR-API-KEY",
-  {
-    method: "POST", // Optional, defaults to endpoint's httpMethod
-    data: { // Optional request body
-      query: "example",
-      limit: 10
-    }
-  }
+```typescript
+// Native SOL transfer
+const txHash = await apiNow.buy(
+  'RECIPIENT_ADDRESS',
+  BigInt(LAMPORTS_PER_SOL), // 1 SOL
+  'YOUR_PRIVATE_KEY',
+  'YOUR_RPC_URL',
+  'sol'
+);
+
+// SPL token transfer
+const txHash = await apiNow.buy(
+  'RECIPIENT_ADDRESS',
+  BigInt(1000000), // Amount in raw units (e.g. 1.0 for 6 decimals)
+  'YOUR_PRIVATE_KEY',
+  'YOUR_RPC_URL',
+  'sol',
+  'TOKEN_ADDRESS'
 );
 ```
 
+## API Reference
+
+### `info(endpoint: string): Promise<InfoResponse>`
+
+Gets information about an endpoint.
+
+### `buy(walletAddress: string, amount: bigint, pkey: string, rpc: string, chain?: 'eth' | 'sol', tokenAddress?: string, fastMode?: boolean): Promise<string>`
+
+Sends a payment transaction. For tokens, provide the amount in raw units (e.g. wei for ERC20, raw units for SPL).
+
+### `txResponse(endpoint: string, txHash: string, opts?: TxResponseOptions): Promise<any>`
+
+Gets the API response for a transaction.
+
+### `infoBuyResponse(endpoint: string, pkey: string, rpc: string, opts?: TxResponseOptions & { fastMode?: boolean }): Promise<any>`
+
+Combines info, buy, and txResponse into a single call.
+
+## Types
+
+```typescript
+interface TxResponseOptions {
+  method?: string;
+  data?: any;
+}
+
+interface InfoResponse {
+  requiredAmount: string;
+  walletAddress: string;
+  httpMethod: string;
+  tokenAddress?: string;
+  chain: 'eth' | 'sol';
+}
+```
+
+## Error Handling
+
+The SDK throws descriptive errors for various failure cases:
+- Invalid endpoint URLs
+- Transaction failures
+- Network issues
+- Invalid addresses or amounts
+
 ## License
 
 MIT

package/dist/index.d.ts

@@ -7,12 +7,16 @@ interface InfoResponse {
     walletAddress: string;
     httpMethod: string;
     tokenAddress?: string;
+    chain: 'eth' | 'sol';
 }
 declare class ApiNow {
+    private handlers;
     info(endpoint: string): Promise<InfoResponse>;
-    buy(walletAddress: string, amount: bigint, pkey: string, rpc: string, tokenAddress?: string): Promise<string>;
+    buy(walletAddress: string, amount: bigint, pkey: string, rpc: string, chain?: 'eth' | 'sol', tokenAddress?: string, fastMode?: boolean): Promise<string>;
     txResponse(endpoint: string, txHash: string, opts?: TxResponseOptions): Promise<any>;
-    infoBuyResponse(endpoint: string, pkey: string, rpc: string, opts?: TxResponseOptions): Promise<any>;
+    infoBuyResponse(endpoint: string, pkey: string, rpc: string, opts?: TxResponseOptions & {
+        fastMode?: boolean;
+    }): Promise<any>;
 }
 declare const _default: ApiNow;
 export default _default;

package/dist/index.js

@@ -5,19 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const node_fetch_1 = __importDefault(require("node-fetch"));
-class ApiNow {
-    async info(endpoint) {
-        if (!endpoint.startsWith('https://apinow.fun/api/endpoints/')) {
-            throw new Error('Invalid endpoint URL format');
-        }
-        console.log(`Fetching info from ${endpoint}`);
-        const response = await (0, node_fetch_1.default)(`${endpoint}`);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch endpoint info: ${response.status}`);
-        }
-        return response.json();
-    }
-    async buy(walletAddress, amount, pkey, rpc, tokenAddress) {
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const bs58_1 = __importDefault(require("bs58"));
+class EthereumHandler {
+    async buy(walletAddress, amount, pkey, rpc, tokenAddress, fastMode) {
         if (!rpc || typeof rpc !== 'string') {
             throw new Error('Invalid RPC URL');
         }
@@ -35,14 +27,12 @@ class ApiNow {
                 ? 30000
                 : 21000;
             if (tokenAddress) {
-                // ERC20 transfer
                 const abi = ["function transfer(address to, uint256 amount) returns (bool)"];
                 const tokenContract = new ethers_1.ethers.Contract(tokenAddress, abi, wallet);
                 const tx = await tokenContract.transfer(walletAddress, amount);
                 return tx.hash;
             }
             else {
-                // Native ETH transfer
                 const tx = await wallet.sendTransaction({
                     to: walletAddress,
                     value: amount,
@@ -60,6 +50,135 @@ class ApiNow {
             throw new Error(`Transaction failed: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+}
+class SolanaHandler {
+    async sendWithRetry(connection, transaction, senderKeypair, fastMode, maxAttempts = 3) {
+        let lastError;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                console.log(`\nAttempt ${attempt}/${maxAttempts}`);
+                const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('processed');
+                console.log('Got blockhash:', blockhash.slice(0, 10) + '...');
+                transaction.recentBlockhash = blockhash;
+                transaction.lastValidBlockHeight = lastValidBlockHeight;
+                transaction.feePayer = senderKeypair.publicKey;
+                transaction.signatures = [];
+                transaction.sign(senderKeypair);
+                const rawTx = transaction.serialize();
+                const signature = await connection.sendRawTransaction(rawTx, {
+                    skipPreflight: false,
+                    maxRetries: 1,
+                    preflightCommitment: 'processed'
+                });
+                console.log('Transaction sent! Signature:', signature);
+                if (!fastMode) {
+                    console.log('Waiting for confirmation...');
+                    let confirmationAttempt = 1;
+                    while (confirmationAttempt <= 5) {
+                        try {
+                            console.log(`Confirmation attempt ${confirmationAttempt}/5`);
+                            await connection.confirmTransaction({
+                                signature,
+                                blockhash,
+                                lastValidBlockHeight
+                            }, 'processed');
+                            console.log('Transaction confirmed!');
+                            return signature;
+                        }
+                        catch (confirmError) {
+                            const errorMessage = confirmError instanceof Error
+                                ? confirmError.message
+                                : 'Unknown confirmation error';
+                            console.log('Confirmation failed:', errorMessage);
+                            if (confirmationAttempt === 5)
+                                throw confirmError;
+                            confirmationAttempt++;
+                            await new Promise(resolve => setTimeout(resolve, 1000));
+                        }
+                    }
+                }
+                return signature;
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error
+                    ? error.message
+                    : 'Unknown error';
+                console.log('Attempt failed:', errorMessage);
+                lastError = error;
+                if (attempt < maxAttempts) {
+                    console.log('Waiting 500ms before retry...');
+                    await new Promise(resolve => setTimeout(resolve, 500));
+                }
+            }
+        }
+        throw lastError;
+    }
+    async buy(walletAddress, amount, pkey, rpc, tokenAddress, fastMode) {
+        const connection = new web3_js_1.Connection(rpc, {
+            commitment: 'processed',
+            confirmTransactionInitialTimeout: 10000
+        });
+        try {
+            const recipientPubkey = new web3_js_1.PublicKey(walletAddress);
+            const senderKeypair = web3_js_1.Keypair.fromSecretKey(bs58_1.default.decode(pkey));
+            const transaction = new web3_js_1.Transaction();
+            // Add priority fee instruction
+            transaction.add(web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
+                microLamports: 50000
+            }));
+            if (tokenAddress) {
+                const mint = new web3_js_1.PublicKey(tokenAddress);
+                const senderATA = await (0, spl_token_1.getAssociatedTokenAddress)(mint, senderKeypair.publicKey);
+                const recipientATA = await (0, spl_token_1.getAssociatedTokenAddress)(mint, recipientPubkey);
+                // Get token decimals
+                const mintInfo = await (0, spl_token_1.getMint)(connection, mint);
+                console.log('Token decimals:', mintInfo.decimals);
+                console.log('Original amount:', amount.toString());
+                // Don't multiply by decimals since amount is already raw
+                transaction.add((0, spl_token_1.createTransferInstruction)(senderATA, recipientATA, senderKeypair.publicKey, Number(amount) // Use raw amount directly
+                ));
+            }
+            else {
+                // SOL transfer
+                transaction.add(web3_js_1.SystemProgram.transfer({
+                    fromPubkey: senderKeypair.publicKey,
+                    toPubkey: recipientPubkey,
+                    lamports: Number(amount)
+                }));
+            }
+            return await this.sendWithRetry(connection, transaction, senderKeypair, !!fastMode);
+        }
+        catch (error) {
+            console.error('Detailed error:', error);
+            throw new Error(`Transaction failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}
+class ApiNow {
+    constructor() {
+        this.handlers = {
+            eth: new EthereumHandler(),
+            sol: new SolanaHandler()
+        };
+    }
+    async info(endpoint) {
+        if (!endpoint.startsWith('https://apinow.fun/api/endpoints/')) {
+            throw new Error('Invalid endpoint URL format');
+        }
+        console.log(`Fetching info from ${endpoint}`);
+        const response = await (0, node_fetch_1.default)(`${endpoint}`);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch endpoint info: ${response.status}`);
+        }
+        return response.json();
+    }
+    async buy(walletAddress, amount, pkey, rpc, chain = 'eth', tokenAddress, fastMode) {
+        const handler = this.handlers[chain];
+        if (!handler) {
+            throw new Error(`Unsupported chain: ${chain}`);
+        }
+        return handler.buy(walletAddress, amount, pkey, rpc, tokenAddress, fastMode);
+    }
     async txResponse(endpoint, txHash, opts = {}) {
         if (!endpoint.startsWith('https://apinow.fun/api/endpoints/')) {
             throw new Error('Invalid endpoint URL format');
@@ -81,8 +200,10 @@ class ApiNow {
     }
     async infoBuyResponse(endpoint, pkey, rpc, opts = {}) {
         const info = await this.info(endpoint);
-        const amount = ethers_1.ethers.parseEther(info.requiredAmount);
-        const txHash = await this.buy(info.walletAddress, amount, pkey, rpc, info.tokenAddress);
+        const amount = info.chain === 'sol'
+            ? BigInt(Math.round(Number(info.requiredAmount) * web3_js_1.LAMPORTS_PER_SOL))
+            : ethers_1.ethers.parseEther(info.requiredAmount);
+        const txHash = await this.buy(info.walletAddress, amount, pkey, rpc, info.chain, info.tokenAddress, opts.fastMode);
         console.log('infoBuyResponse:', { endpoint, txHash, ...opts });
         const response = await this.txResponse(endpoint, txHash, {
             method: opts.method || info.httpMethod,

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "apinow-sdk",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "ApiNow SDK · The endpoint vending machine",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "type": "module",
   "files": [
     "dist"
   ],
@@ -20,6 +21,9 @@
   "author": "Your Name",
   "license": "MIT",
   "dependencies": {
+    "@solana/spl-token": "^0.4.12",
+    "@solana/web3.js": "^1.98.0",
+    "bs58": "^6.0.0",
     "ethers": "^6.13.5",
     "node-fetch": "^3.3.2"
   },