@velociti/sdk 0.1.0 → 0.2.1

package/dist/client.js

@@ -6,7 +6,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VelocitiClient = void 0;
 const DEFAULT_MAINNET_URL = 'https://velociti.fun/api/sdk';
-const DEFAULT_DEVNET_URL = 'https://devnet.velociti.fun/api/sdk';
+const DEFAULT_DEVNET_URL = 'https://velociti.fun/api/sdk'; // Same URL, network param handled internally
 class VelocitiClient {
     constructor(config) {
         this.rateLimitInfo = null;
@@ -14,73 +14,92 @@ class VelocitiClient {
             throw new Error('API key is required. Get one at velociti.fun/developers');
         }
         this.apiKey = config.apiKey;
-        this.network = config.network || 'mainnet';
+        this.network = config.network || 'devnet';
         this.baseUrl = config.baseUrl ||
             (this.network === 'mainnet' ? DEFAULT_MAINNET_URL : DEFAULT_DEVNET_URL);
+        // Retry configuration
+        this.enableRetry = config.enableRetry ?? true;
+        this.maxRetries = config.maxRetries ?? 3;
+        this.retryDelay = config.retryDelay ?? 1000;
     }
     /**
-     * Make an authenticated request to the VELOCITI API
+     * Sleep helper for retry logic
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Make an authenticated request to the VELOCITI API with retry logic
      */
     async request(endpoint, options = {}) {
-        const url = `${this.baseUrl}${endpoint}`;
-        const response = await fetch(url, {
-            ...options,
-            headers: {
-                'Content-Type': 'application/json',
-                'X-API-Key': this.apiKey,
-                ...options.headers,
-            },
-        });
-        // Update rate limit info from headers
-        const remaining = response.headers.get('X-RateLimit-Remaining');
-        const limit = response.headers.get('X-RateLimit-Limit');
-        const reset = response.headers.get('X-RateLimit-Reset');
-        if (remaining && limit && reset) {
-            this.rateLimitInfo = {
-                remaining: parseInt(remaining, 10),
-                limit: parseInt(limit, 10),
-                reset: parseInt(reset, 10),
-            };
-        }
-        if (response.status === 429) {
-            return {
-                success: false,
-                error: 'Rate limit exceeded. Please try again later.',
-            };
-        }
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => ({}));
-            return {
-                success: false,
-                error: errorData.error || `HTTP ${response.status}: ${response.statusText}`,
-            };
+        let lastError = null;
+        const attempts = this.enableRetry ? this.maxRetries : 1;
+        for (let attempt = 1; attempt <= attempts; attempt++) {
+            try {
+                const url = `${this.baseUrl}${endpoint}`;
+                const response = await fetch(url, {
+                    ...options,
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'X-API-Key': this.apiKey,
+                        ...options.headers,
+                    },
+                });
+                // Update rate limit info from headers
+                const remaining = response.headers.get('X-RateLimit-Remaining');
+                const limit = response.headers.get('X-RateLimit-Limit');
+                const reset = response.headers.get('X-RateLimit-Reset');
+                if (remaining && limit && reset) {
+                    this.rateLimitInfo = {
+                        remaining: parseInt(remaining, 10),
+                        limit: parseInt(limit, 10),
+                        reset: parseInt(reset, 10),
+                    };
+                }
+                if (response.status === 429) {
+                    // Rate limited - retry with exponential backoff
+                    if (attempt < attempts) {
+                        await this.sleep(this.retryDelay * Math.pow(2, attempt - 1));
+                        continue;
+                    }
+                    return {
+                        success: false,
+                        error: 'Rate limit exceeded. Please try again later.',
+                    };
+                }
+                if (response.status >= 500 && attempt < attempts) {
+                    // Server error - retry
+                    await this.sleep(this.retryDelay * Math.pow(2, attempt - 1));
+                    continue;
+                }
+                if (!response.ok) {
+                    const errorData = await response.json().catch(() => ({}));
+                    return {
+                        success: false,
+                        error: errorData.error || `HTTP ${response.status}: ${response.statusText}`,
+                    };
+                }
+                const data = await response.json();
+                return { success: true, data };
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt < attempts) {
+                    await this.sleep(this.retryDelay * Math.pow(2, attempt - 1));
+                    continue;
+                }
+            }
         }
-        const data = await response.json();
-        return { success: true, data };
+        return {
+            success: false,
+            error: lastError?.message || 'Request failed after retries',
+        };
     }
     /**
      * Prepare a token deployment transaction (Step 1)
      *
      * Returns an unsigned transaction that you must sign with your wallet.
      * After signing, call submitTransaction() to complete the deployment.
-     *
-     * @example
-     * ```typescript
-     * // Step 1: Prepare the transaction
-     * const prepared = await client.prepareTokenDeploy({
-     *   name: 'My Token',
-     *   symbol: 'MTK',
-     *   taxRate: 5,
-     *   payerAddress: 'YourWalletAddress...'
-     * });
-     *
-     * // Step 2: Sign with your wallet (example using @solana/web3.js)
-     * const tx = Transaction.from(Buffer.from(prepared.data.transaction, 'base64'));
-     * const signedTx = await wallet.signTransaction(tx);
-     *
-     * // Step 3: Submit the signed transaction
-     * const result = await client.submitTransaction(signedTx.serialize().toString('base64'));
-     * ```
      */
     async prepareTokenDeploy(params) {
         // Validate params
@@ -114,40 +133,47 @@ class VelocitiClient {
     }
     /**
      * Convenience method: Deploy token in one call (requires wallet adapter)
-     *
-     * This combines prepareTokenDeploy and submitTransaction.
-     * You must provide a signTransaction function from your wallet.
-     *
-     * @example
-     * ```typescript
-     * const result = await client.deployToken({
-     *   name: 'My Token',
-     *   symbol: 'MTK',
-     *   taxRate: 5,
-     *   payerAddress: wallet.publicKey.toBase58()
-     * }, async (tx) => {
-     *   return await wallet.signTransaction(tx);
-     * });
-     * ```
      */
     async deployToken(params, signTransaction) {
-        // Step 1: Prepare
         const prepared = await this.prepareTokenDeploy(params);
         if (!prepared.success || !prepared.data) {
             return { success: false, error: prepared.error || 'Failed to prepare transaction' };
         }
-        // Step 2: Sign
         try {
-            const txBytes = Uint8Array.from(atob(prepared.data.transaction), c => c.charCodeAt(0));
+            const txBytes = Uint8Array.from(atob(prepared.data.transaction), (c) => c.charCodeAt(0));
             const signedBytes = await signTransaction(txBytes);
             const signedBase64 = btoa(String.fromCharCode(...signedBytes));
-            // Step 3: Submit
             return this.submitTransaction(signedBase64);
         }
         catch (error) {
-            return { success: false, error: `Signing failed: ${error.message}` };
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            return { success: false, error: `Signing failed: ${message}` };
+        }
+    }
+    // ============================================
+    // BATCH DEPLOY
+    // ============================================
+    /**
+     * Prepare multiple token deployments in batch
+     */
+    async prepareBatchDeploy(params) {
+        if (!params.tokens || params.tokens.length === 0) {
+            return { success: false, error: 'At least one token is required' };
+        }
+        if (params.tokens.length > 10) {
+            return { success: false, error: 'Maximum 10 tokens per batch' };
+        }
+        if (!params.payerAddress) {
+            return { success: false, error: 'Payer address is required' };
         }
+        return this.request('/deploy/batch', {
+            method: 'POST',
+            body: JSON.stringify(params),
+        });
     }
+    // ============================================
+    // TOKEN ANALYTICS
+    // ============================================
     /**
      * Get token information by mint address
      */
@@ -160,6 +186,23 @@ class VelocitiClient {
     async getMyTokens() {
         return this.request('/tokens/mine');
     }
+    /**
+     * Get detailed analytics for a token
+     */
+    async getTokenAnalytics(mintAddress) {
+        return this.request(`/tokens/${mintAddress}/analytics`);
+    }
+    /**
+     * Get price history for a token
+     * @param mintAddress - Token mint address
+     * @param period - Time period: '1h', '24h', '7d', '30d'
+     */
+    async getPriceHistory(mintAddress, period = '24h') {
+        return this.request(`/tokens/${mintAddress}/price-history?period=${period}`);
+    }
+    // ============================================
+    // FEE CLAIMING
+    // ============================================
     /**
      * Prepare fee claim transaction
      */
@@ -171,7 +214,6 @@ class VelocitiClient {
     }
     /**
      * Claim accumulated transfer fees for a token
-     * Combines prepare + sign + submit
      */
     async claimFees(mintAddress, walletAddress, signTransaction) {
         const prepared = await this.prepareClaimFees(mintAddress, walletAddress);
@@ -179,7 +221,7 @@ class VelocitiClient {
             return { success: false, error: prepared.error || 'Failed to prepare claim' };
         }
         try {
-            const txBytes = Uint8Array.from(atob(prepared.data.transaction), c => c.charCodeAt(0));
+            const txBytes = Uint8Array.from(atob(prepared.data.transaction), (c) => c.charCodeAt(0));
             const signedBytes = await signTransaction(txBytes);
             const signedBase64 = btoa(String.fromCharCode(...signedBytes));
             return this.request('/fees/submit', {
@@ -188,7 +230,8 @@ class VelocitiClient {
             });
         }
         catch (error) {
-            return { success: false, error: `Signing failed: ${error.message}` };
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            return { success: false, error: `Signing failed: ${message}` };
         }
     }
     /**
@@ -197,6 +240,43 @@ class VelocitiClient {
     async getUnclaimedFees(mintAddress) {
         return this.request(`/fees/${mintAddress}`);
     }
+    // ============================================
+    // WEBHOOKS
+    // ============================================
+    /**
+     * Register a webhook to receive events
+     */
+    async registerWebhook(config) {
+        return this.request('/webhooks', {
+            method: 'POST',
+            body: JSON.stringify(config),
+        });
+    }
+    /**
+     * List all registered webhooks
+     */
+    async listWebhooks() {
+        return this.request('/webhooks');
+    }
+    /**
+     * Delete a webhook
+     */
+    async deleteWebhook(webhookId) {
+        return this.request(`/webhooks/${webhookId}`, {
+            method: 'DELETE',
+        });
+    }
+    /**
+     * Test a webhook endpoint
+     */
+    async testWebhook(webhookId) {
+        return this.request(`/webhooks/${webhookId}/test`, {
+            method: 'POST',
+        });
+    }
+    // ============================================
+    // UTILITY METHODS
+    // ============================================
     /**
      * Get current rate limit status
      */
@@ -209,5 +289,11 @@ class VelocitiClient {
     getNetwork() {
         return this.network;
     }
+    /**
+     * Check if API key is valid
+     */
+    async validateApiKey() {
+        return this.request('/auth/validate');
+    }
 }
 exports.VelocitiClient = VelocitiClient;

package/dist/index.d.ts

@@ -17,6 +17,9 @@
  *   taxRate: 5
  * });
  * ```
+ *
+ * @packageDocumentation
  */
 export { VelocitiClient } from './client';
 export * from './types';
+export * from './react';

package/dist/index.js

@@ -18,6 +18,8 @@
  *   taxRate: 5
  * });
  * ```
+ *
+ * @packageDocumentation
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -38,3 +40,5 @@ exports.VelocitiClient = void 0;
 var client_1 = require("./client");
 Object.defineProperty(exports, "VelocitiClient", { enumerable: true, get: function () { return client_1.VelocitiClient; } });
 __exportStar(require("./types"), exports);
+// React hooks (for client-side use)
+__exportStar(require("./react"), exports);

package/dist/react.d.ts

@@ -0,0 +1,65 @@
+/**
+ * React Hooks for VELOCITI SDK
+ *
+ * Usage with Solana wallet adapter:
+ *
+ * import { useVelocitiDeploy } from '@velociti/sdk/react';
+ * import { useWallet } from '@solana/wallet-adapter-react';
+ *
+ * function DeployButton() {
+ *   const { signTransaction } = useWallet();
+ *   const { deploy, loading, error } = useVelocitiDeploy('your-api-key');
+ *
+ *   const handleDeploy = async () => {
+ *     const result = await deploy({
+ *       name: 'MyToken',
+ *       symbol: 'MTK',
+ *       taxRate: 5,
+ *       payerAddress: wallet.publicKey.toBase58()
+ *     }, signTransaction);
+ *
+ *     if (result.success) {
+ *       console.log('Deployed!', result.data);
+ *     }
+ *   };
+ * }
+ */
+import { VelocitiClient } from './client';
+import { DeployTokenParams, TokenInfo, TokenAnalytics, ApiResponse, SubmitResult } from './types';
+export declare function useVelocitiDeploy(apiKey: string, network?: 'mainnet' | 'devnet'): {
+    deploy: (params: DeployTokenParams, signTransaction: (transaction: Uint8Array) => Promise<Uint8Array>) => Promise<ApiResponse<SubmitResult>>;
+    prepareTransaction: (params: DeployTokenParams) => Promise<ApiResponse<import("./types").PreparedTransaction>>;
+    submitTransaction: (signedTransaction: string) => Promise<ApiResponse<SubmitResult>>;
+    loading: boolean;
+    error: null;
+    result: null;
+    client: VelocitiClient;
+};
+export declare function useVelocitiToken(apiKey: string, mintAddress: string, network?: 'mainnet' | 'devnet'): {
+    fetch: () => Promise<TokenInfo | null>;
+    refresh: () => Promise<TokenInfo | null>;
+    loading: boolean;
+    error: null;
+    token: null;
+};
+export declare function useVelocitiAnalytics(apiKey: string, mintAddress: string, network?: 'mainnet' | 'devnet'): {
+    fetch: () => Promise<TokenAnalytics | null>;
+    loading: boolean;
+    error: null;
+    analytics: null;
+};
+export declare function useVelocitiMyTokens(apiKey: string, network?: 'mainnet' | 'devnet'): {
+    fetch: () => Promise<TokenInfo[]>;
+    loading: boolean;
+    error: null;
+    tokens: TokenInfo[];
+};
+export declare function useVelocitiFees(apiKey: string, mintAddress: string, network?: 'mainnet' | 'devnet'): {
+    getUnclaimedFees: () => Promise<ApiResponse<{
+        amount: string;
+        valueInSol: number;
+    }>>;
+    claim: (walletAddress: string, signTransaction: (transaction: Uint8Array) => Promise<Uint8Array>) => Promise<ApiResponse<import("./types").ClaimFeesResult>>;
+    loading: boolean;
+    error: null;
+};

package/dist/react.js

@@ -0,0 +1,235 @@
+"use strict";
+/**
+ * React Hooks for VELOCITI SDK
+ *
+ * Usage with Solana wallet adapter:
+ *
+ * import { useVelocitiDeploy } from '@velociti/sdk/react';
+ * import { useWallet } from '@solana/wallet-adapter-react';
+ *
+ * function DeployButton() {
+ *   const { signTransaction } = useWallet();
+ *   const { deploy, loading, error } = useVelocitiDeploy('your-api-key');
+ *
+ *   const handleDeploy = async () => {
+ *     const result = await deploy({
+ *       name: 'MyToken',
+ *       symbol: 'MTK',
+ *       taxRate: 5,
+ *       payerAddress: wallet.publicKey.toBase58()
+ *     }, signTransaction);
+ *
+ *     if (result.success) {
+ *       console.log('Deployed!', result.data);
+ *     }
+ *   };
+ * }
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useVelocitiFees = exports.useVelocitiMyTokens = exports.useVelocitiAnalytics = exports.useVelocitiToken = exports.useVelocitiDeploy = void 0;
+const client_1 = require("./client");
+// React hook for token deployment
+function useVelocitiDeploy(apiKey, network = 'devnet') {
+    let loading = false;
+    let error = null;
+    let result = null;
+    const client = new client_1.VelocitiClient({ apiKey, network });
+    async function deploy(params, signTransaction) {
+        loading = true;
+        error = null;
+        try {
+            const response = await client.deployToken(params, signTransaction);
+            if (response.success && response.data) {
+                result = response.data;
+            }
+            else {
+                error = response.error || 'Unknown error';
+            }
+            return response;
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : 'Unknown error';
+            error = message;
+            return { success: false, error: message };
+        }
+        finally {
+            loading = false;
+        }
+    }
+    async function prepareTransaction(params) {
+        loading = true;
+        try {
+            return await client.prepareTokenDeploy(params);
+        }
+        finally {
+            loading = false;
+        }
+    }
+    async function submitTransaction(signedTransaction) {
+        loading = true;
+        try {
+            return await client.submitTransaction(signedTransaction);
+        }
+        finally {
+            loading = false;
+        }
+    }
+    return {
+        deploy,
+        prepareTransaction,
+        submitTransaction,
+        loading,
+        error,
+        result,
+        client,
+    };
+}
+exports.useVelocitiDeploy = useVelocitiDeploy;
+// React hook for fetching token info
+function useVelocitiToken(apiKey, mintAddress, network = 'devnet') {
+    let loading = false;
+    let error = null;
+    let token = null;
+    const client = new client_1.VelocitiClient({ apiKey, network });
+    async function fetch() {
+        loading = true;
+        error = null;
+        try {
+            const response = await client.getToken(mintAddress);
+            if (response.success && response.data) {
+                token = response.data;
+                return token;
+            }
+            else {
+                error = response.error || 'Failed to fetch token';
+                return null;
+            }
+        }
+        catch (e) {
+            error = e instanceof Error ? e.message : 'Unknown error';
+            return null;
+        }
+        finally {
+            loading = false;
+        }
+    }
+    async function refresh() {
+        return fetch();
+    }
+    return {
+        fetch,
+        refresh,
+        loading,
+        error,
+        token,
+    };
+}
+exports.useVelocitiToken = useVelocitiToken;
+// React hook for token analytics
+function useVelocitiAnalytics(apiKey, mintAddress, network = 'devnet') {
+    let loading = false;
+    let error = null;
+    let analytics = null;
+    const client = new client_1.VelocitiClient({ apiKey, network });
+    async function fetch() {
+        loading = true;
+        error = null;
+        try {
+            const response = await client.getTokenAnalytics(mintAddress);
+            if (response.success && response.data) {
+                analytics = response.data;
+                return analytics;
+            }
+            else {
+                error = response.error || 'Failed to fetch analytics';
+                return null;
+            }
+        }
+        catch (e) {
+            error = e instanceof Error ? e.message : 'Unknown error';
+            return null;
+        }
+        finally {
+            loading = false;
+        }
+    }
+    return {
+        fetch,
+        loading,
+        error,
+        analytics,
+    };
+}
+exports.useVelocitiAnalytics = useVelocitiAnalytics;
+// React hook for listing user's tokens
+function useVelocitiMyTokens(apiKey, network = 'devnet') {
+    let loading = false;
+    let error = null;
+    let tokens = [];
+    const client = new client_1.VelocitiClient({ apiKey, network });
+    async function fetch() {
+        loading = true;
+        error = null;
+        try {
+            const response = await client.getMyTokens();
+            if (response.success && response.data) {
+                tokens = response.data;
+                return tokens;
+            }
+            else {
+                error = response.error || 'Failed to fetch tokens';
+                return [];
+            }
+        }
+        catch (e) {
+            error = e instanceof Error ? e.message : 'Unknown error';
+            return [];
+        }
+        finally {
+            loading = false;
+        }
+    }
+    return {
+        fetch,
+        loading,
+        error,
+        tokens,
+    };
+}
+exports.useVelocitiMyTokens = useVelocitiMyTokens;
+// React hook for fee claiming
+function useVelocitiFees(apiKey, mintAddress, network = 'mainnet') {
+    let loading = false;
+    let error = null;
+    const client = new client_1.VelocitiClient({ apiKey, network });
+    async function getUnclaimedFees() {
+        loading = true;
+        try {
+            return await client.getUnclaimedFees(mintAddress);
+        }
+        finally {
+            loading = false;
+        }
+    }
+    async function claim(walletAddress, signTransaction) {
+        loading = true;
+        error = null;
+        try {
+            return await client.claimFees(mintAddress, walletAddress, signTransaction);
+        }
+        catch (e) {
+            error = e instanceof Error ? e.message : 'Unknown error';
+            return { success: false, error };
+        }
+        finally {
+            loading = false;
+        }
+    }
+    return {
+        getUnclaimedFees,
+        claim,
+        loading,
+        error,
+    };
+}
+exports.useVelocitiFees = useVelocitiFees;