@velociti/sdk 0.1.0 → 0.2.0

package/dist/types.d.ts

@@ -10,6 +10,12 @@ export interface VelocitiConfig {
     network?: 'mainnet' | 'devnet';
     /** Custom API base URL (optional) */
     baseUrl?: string;
+    /** Enable retry logic for failed requests */
+    enableRetry?: boolean;
+    /** Max retry attempts (default: 3) */
+    maxRetries?: number;
+    /** Retry delay in ms (default: 1000) */
+    retryDelay?: number;
 }
 /** Token deployment configuration */
 export interface DeployTokenParams {
@@ -32,6 +38,25 @@ export interface DeployTokenParams {
         website?: string;
     };
 }
+/** Batch deploy parameters */
+export interface BatchDeployParams {
+    /** Array of tokens to deploy */
+    tokens: DeployTokenParams[];
+    /** Single payer for all tokens */
+    payerAddress: string;
+}
+/** Batch deploy result */
+export interface BatchDeployResult {
+    /** Individual results for each token */
+    results: Array<{
+        index: number;
+        success: boolean;
+        mintAddress?: string;
+        error?: string;
+    }>;
+    /** Total estimated fee for all tokens */
+    totalEstimatedFee: number;
+}
 /** Prepared transaction ready for signing */
 export interface PreparedTransaction {
     /** Base64 encoded serialized transaction */
@@ -80,6 +105,29 @@ export interface TokenInfo {
     /** Created at timestamp */
     createdAt: string;
 }
+/** Token analytics data */
+export interface TokenAnalytics {
+    /** Token mint address */
+    mintAddress: string;
+    /** Price history (hourly for last 24h) */
+    priceHistory: Array<{
+        timestamp: number;
+        price: number;
+        volume: number;
+    }>;
+    /** 24h volume in SOL */
+    volume24h: number;
+    /** 24h price change percentage */
+    priceChange24h: number;
+    /** Number of unique holders */
+    holders: number;
+    /** Total number of trades */
+    trades: number;
+    /** All-time high price in SOL */
+    allTimeHigh: number;
+    /** All-time low price in SOL */
+    allTimeLow: number;
+}
 /** Fee claiming result */
 export interface ClaimFeesResult {
     /** Transaction signature */
@@ -100,6 +148,31 @@ export interface SubmitResult {
     /** Error message if failed */
     error?: string;
 }
+/** Webhook configuration */
+export interface WebhookConfig {
+    /** Webhook URL to receive events */
+    url: string;
+    /** Events to subscribe to */
+    events: WebhookEvent[];
+    /** Optional secret for signature verification */
+    secret?: string;
+}
+/** Webhook event types */
+export type WebhookEvent = 'token.created' | 'token.graduated' | 'token.trade' | 'fees.claimed' | 'fees.available';
+/** Webhook payload */
+export interface WebhookPayload {
+    /** Event type */
+    event: WebhookEvent;
+    /** Event timestamp */
+    timestamp: number;
+    /** Event data */
+    data: {
+        mintAddress: string;
+        [key: string]: unknown;
+    };
+    /** Signature for verification */
+    signature?: string;
+}
 /** API response wrapper */
 export interface ApiResponse<T> {
     success: boolean;

package/package.json

@@ -1,13 +1,17 @@
 {
     "name": "@velociti/sdk",
-    "version": "0.1.0",
+    "version": "0.2.0",
     "description": "Official SDK for deploying and managing tokens on VELOCITI - the Solana tax token launchpad",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
+    "bin": {
+        "velociti": "./dist/cli.js"
+    },
     "scripts": {
         "build": "tsc",
         "test": "jest",
-        "prepublishOnly": "npm run build"
+        "prepublishOnly": "npm run build",
+        "docs": "typedoc --out docs/api src/index.ts"
     },
     "keywords": [
         "solana",
@@ -16,7 +20,9 @@
         "velociti",
         "tax-token",
         "token-2022",
-        "ai-agent"
+        "ai-agent",
+        "cli",
+        "sdk"
     ],
     "author": "VELOCITI",
     "license": "MIT",
@@ -25,11 +31,24 @@
     },
     "devDependencies": {
         "@types/node": "^20.0.0",
+        "typedoc": "^0.25.0",
         "typescript": "^5.3.0"
     },
     "repository": {
         "type": "git",
         "url": "https://github.com/Velociti-Launchpad/velociti-sdk"
     },
-    "homepage": "https://velociti.fun/developers"
+    "homepage": "https://velociti.fun/developers",
+    "bugs": {
+        "url": "https://github.com/Velociti-Launchpad/velociti-sdk/issues"
+    },
+    "files": [
+        "dist",
+        "README.md",
+        "LICENSE",
+        "CHANGELOG.md"
+    ],
+    "engines": {
+        "node": ">=18.0.0"
+    }
 }

package/docs/getting-started.md

@@ -1,73 +0,0 @@
-# Getting Started with VELOCITI SDK
-
-This guide will help you set up and deploy your first token using the VELOCITI SDK.
-
-## Prerequisites
-
-- Node.js 18+
-- npm or yarn
-- A VELOCITI API key
-
-## Step 1: Get Your API Key
-
-1. Visit [velociti.fun/developers](https://velociti.fun/developers)
-2. Fill out the access request form with:
-   - Your name and email
-   - Project name and description
-   - Intended use case
-3. Wait for approval (usually within 24 hours)
-4. Check your email for your API key
-
-## Step 2: Install the SDK
-
-```bash
-npm install @velociti/sdk
-```
-
-## Step 3: Initialize the Client
-
-```typescript
-import { VelocitiClient } from '@velociti/sdk';
-
-const client = new VelocitiClient({
-  apiKey: process.env.VELOCITI_API_KEY,
-  network: 'devnet' // Start with devnet for testing
-});
-```
-
-## Step 4: Deploy Your First Token
-
-```typescript
-const result = await client.deployToken({
-  name: 'My First Token',
-  symbol: 'MFT',
-  description: 'My first token on VELOCITI',
-  taxRate: 5, // 5% transfer tax
-});
-
-if (result.success) {
-  console.log('Token deployed!', result.data?.mintAddress);
-} else {
-  console.error('Failed:', result.error);
-}
-```
-
-## Step 5: Monitor and Claim Fees
-
-```typescript
-// Check unclaimed fees
-const fees = await client.getUnclaimedFees(result.data.mintAddress);
-console.log('Unclaimed fees:', fees.data?.amount);
-
-// Claim fees to your wallet
-const claim = await client.claimFees(
-  result.data.mintAddress,
-  'YourWalletAddress...'
-);
-```
-
-## Next Steps
-
-- Explore the [API Reference](./api-reference.md)
-- Check out [examples](../examples/)
-- Join our [Discord](https://discord.gg/velociti) for support

package/examples/deploy-token.ts

@@ -1,75 +0,0 @@
-/**
- * Example: Deploy a token on VELOCITI
- * 
- * This example shows the 2-step flow:
- * 1. Prepare transaction (API builds it with all program addresses)
- * 2. Sign & submit (you pay the fees)
- * 
- * Run with: npx ts-node examples/deploy-token.ts
- */
-
-import { VelocitiClient } from '../src';
-import { Keypair, Transaction } from '@solana/web3.js';
-
-async function main() {
-    // Initialize the client with your API key
-    const client = new VelocitiClient({
-        apiKey: process.env.VELOCITI_API_KEY || 'your-api-key',
-        network: 'devnet',
-    });
-
-    // Your wallet (in production, use wallet adapter)
-    const wallet = Keypair.generate(); // Demo only!
-
-    console.log('🚀 Preparing token deployment...\n');
-    console.log(`   Wallet: ${wallet.publicKey.toBase58()}`);
-
-    // Step 1: Prepare the transaction
-    // The API builds the full transaction with all program addresses,
-    // PDAs, and accounts. You don't need to know any internal details!
-    const prepared = await client.prepareTokenDeploy({
-        name: 'My AI Token',
-        symbol: 'AIT',
-        description: 'A token deployed by an AI agent',
-        taxRate: 5,
-        payerAddress: wallet.publicKey.toBase58(), // You pay the fees
-        socials: {
-            twitter: '@myaitoken',
-            website: 'https://myaitoken.com',
-        },
-    });
-
-    if (!prepared.success || !prepared.data) {
-        console.error('❌ Prepare failed:', prepared.error);
-        return;
-    }
-
-    console.log('\n📋 Transaction prepared:');
-    console.log(`   Mint Address: ${prepared.data.mintAddress}`);
-    console.log(`   Estimated Fee: ${prepared.data.estimatedFee} SOL`);
-
-    // Step 2: Sign the transaction with your wallet
-    const tx = Transaction.from(Buffer.from(prepared.data.transaction, 'base64'));
-    tx.sign(wallet); // In production: await walletAdapter.signTransaction(tx)
-
-    // Step 3: Submit the signed transaction
-    const signedBase64 = tx.serialize().toString('base64');
-    const result = await client.submitTransaction(signedBase64);
-
-    if (!result.success) {
-        console.error('❌ Deployment failed:', result.error);
-        return;
-    }
-
-    console.log('\n✅ Token deployed successfully!');
-    console.log(`   Signature: ${result.data?.signature}`);
-    console.log(`   View: https://velociti.fun/token/${prepared.data.mintAddress}`);
-
-    // Check rate limit
-    const rateLimit = client.getRateLimitInfo();
-    if (rateLimit) {
-        console.log(`\n📊 Rate Limit: ${rateLimit.remaining}/${rateLimit.limit} remaining`);
-    }
-}
-
-main().catch(console.error);

package/src/client.ts

@@ -1,260 +0,0 @@
-/**
- * VELOCITI SDK Client
- * Main client class for interacting with the VELOCITI API
- */
-
-import {
-    VelocitiConfig,
-    DeployTokenParams,
-    TokenInfo,
-    ClaimFeesResult,
-    ApiResponse,
-    RateLimitInfo,
-    PreparedTransaction,
-    SubmitResult,
-} from './types';
-
-const DEFAULT_MAINNET_URL = 'https://velociti.fun/api/sdk';
-const DEFAULT_DEVNET_URL = 'https://devnet.velociti.fun/api/sdk';
-
-export class VelocitiClient {
-    private apiKey: string;
-    private baseUrl: string;
-    private network: 'mainnet' | 'devnet';
-    private rateLimitInfo: RateLimitInfo | null = null;
-
-    constructor(config: VelocitiConfig) {
-        if (!config.apiKey) {
-            throw new Error('API key is required. Get one at velociti.fun/developers');
-        }
-
-        this.apiKey = config.apiKey;
-        this.network = config.network || 'mainnet';
-        this.baseUrl = config.baseUrl ||
-            (this.network === 'mainnet' ? DEFAULT_MAINNET_URL : DEFAULT_DEVNET_URL);
-    }
-
-    /**
-     * Make an authenticated request to the VELOCITI API
-     */
-    private async request<T>(
-        endpoint: string,
-        options: RequestInit = {}
-    ): Promise<ApiResponse<T>> {
-        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(() => ({})) as { error?: string };
-            return {
-                success: false,
-                error: errorData.error || `HTTP ${response.status}: ${response.statusText}`,
-            };
-        }
-
-        const data = await response.json() as T;
-        return { success: true, data };
-    }
-
-    /**
-     * 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: DeployTokenParams): Promise<ApiResponse<PreparedTransaction>> {
-        // Validate params
-        if (!params.name || params.name.length > 32) {
-            return { success: false, error: 'Name is required and must be <= 32 characters' };
-        }
-        if (!params.symbol || params.symbol.length > 10) {
-            return { success: false, error: 'Symbol is required and must be <= 10 characters' };
-        }
-        if (!params.payerAddress) {
-            return { success: false, error: 'Payer wallet address is required' };
-        }
-        if (params.taxRate !== undefined && (params.taxRate < 0 || params.taxRate > 10)) {
-            return { success: false, error: 'Tax rate must be between 0 and 10%' };
-        }
-
-        return this.request<PreparedTransaction>('/deploy/prepare', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-
-    /**
-     * Submit a signed transaction (Step 2)
-     * 
-     * @param signedTransaction - Base64 encoded signed transaction
-     */
-    async submitTransaction(signedTransaction: string): Promise<ApiResponse<SubmitResult>> {
-        return this.request<SubmitResult>('/deploy/submit', {
-            method: 'POST',
-            body: JSON.stringify({ signedTransaction }),
-        });
-    }
-
-    /**
-     * 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: DeployTokenParams,
-        signTransaction: (transaction: Uint8Array) => Promise<Uint8Array>
-    ): Promise<ApiResponse<SubmitResult>> {
-        // 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 signedBytes = await signTransaction(txBytes);
-            const signedBase64 = btoa(String.fromCharCode(...signedBytes));
-
-            // Step 3: Submit
-            return this.submitTransaction(signedBase64);
-        } catch (error: any) {
-            return { success: false, error: `Signing failed: ${error.message}` };
-        }
-    }
-
-    /**
-     * Get token information by mint address
-     */
-    async getToken(mintAddress: string): Promise<ApiResponse<TokenInfo>> {
-        return this.request<TokenInfo>(`/tokens/${mintAddress}`);
-    }
-
-    /**
-     * Get all tokens created with this API key
-     */
-    async getMyTokens(): Promise<ApiResponse<TokenInfo[]>> {
-        return this.request<TokenInfo[]>('/tokens/mine');
-    }
-
-    /**
-     * Prepare fee claim transaction
-     */
-    async prepareClaimFees(
-        mintAddress: string,
-        walletAddress: string
-    ): Promise<ApiResponse<PreparedTransaction>> {
-        return this.request<PreparedTransaction>('/fees/prepare', {
-            method: 'POST',
-            body: JSON.stringify({ mintAddress, walletAddress }),
-        });
-    }
-
-    /**
-     * Claim accumulated transfer fees for a token
-     * Combines prepare + sign + submit
-     */
-    async claimFees(
-        mintAddress: string,
-        walletAddress: string,
-        signTransaction: (transaction: Uint8Array) => Promise<Uint8Array>
-    ): Promise<ApiResponse<ClaimFeesResult>> {
-        const prepared = await this.prepareClaimFees(mintAddress, walletAddress);
-        if (!prepared.success || !prepared.data) {
-            return { success: false, error: prepared.error || 'Failed to prepare claim' };
-        }
-
-        try {
-            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<ClaimFeesResult>('/fees/submit', {
-                method: 'POST',
-                body: JSON.stringify({ signedTransaction: signedBase64, mintAddress }),
-            });
-        } catch (error: any) {
-            return { success: false, error: `Signing failed: ${error.message}` };
-        }
-    }
-
-    /**
-     * Get unclaimed fees for a token
-     */
-    async getUnclaimedFees(mintAddress: string): Promise<ApiResponse<{ amount: string; valueInSol: number }>> {
-        return this.request(`/fees/${mintAddress}`);
-    }
-
-    /**
-     * Get current rate limit status
-     */
-    getRateLimitInfo(): RateLimitInfo | null {
-        return this.rateLimitInfo;
-    }
-
-    /**
-     * Get the current network
-     */
-    getNetwork(): 'mainnet' | 'devnet' {
-        return this.network;
-    }
-}

package/src/index.ts

@@ -1,23 +0,0 @@
-/**
- * VELOCITI SDK
- * Official SDK for deploying and managing tokens on VELOCITI
- * 
- * @example
- * ```typescript
- * import { VelocitiClient } from '@velociti/sdk';
- * 
- * const client = new VelocitiClient({
- *   apiKey: 'your-api-key',
- *   network: 'devnet'
- * });
- * 
- * const token = await client.deployToken({
- *   name: 'My Token',
- *   symbol: 'MTK',
- *   taxRate: 5
- * });
- * ```
- */
-
-export { VelocitiClient } from './client';
-export * from './types';