@velociti/sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 VELOCITI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,147 @@
+# VELOCITI SDK
+
+Official SDK for deploying and managing tax tokens on [VELOCITI](https://velociti.fun) - the Solana Token-2022 launchpad with built-in transfer taxes.
+
+## Features
+
+- 🚀 **Deploy tokens** with configurable transfer taxes
+- 💰 **Claim fees** accumulated from token transfers
+- 📊 **Track tokens** and monitor performance
+- ⚡ **Rate-limited API** with tiered access
+
+## Installation
+
+```bash
+npm install @velociti/sdk
+# or
+yarn add @velociti/sdk
+```
+
+## Quick Start
+
+```typescript
+import { VelocitiClient } from '@velociti/sdk';
+
+const client = new VelocitiClient({
+  apiKey: 'your-api-key', // Get at velociti.fun/developers
+  network: 'mainnet'      // or 'devnet'
+});
+
+// Deploy a new token
+const token = await client.deployToken({
+  name: 'My Token',
+  symbol: 'MTK',
+  description: 'A token with built-in tax',
+  taxRate: 5, // 5% transfer tax
+  socials: {
+    twitter: '@mytoken',
+    website: 'https://mytoken.com'
+  }
+});
+
+console.log(`Token deployed: ${token.data?.mintAddress}`);
+```
+
+## API Reference
+
+### `VelocitiClient`
+
+#### Constructor
+
+```typescript
+new VelocitiClient({
+  apiKey: string;           // Required: Your API key
+  network?: 'mainnet' | 'devnet';  // Optional: Default 'mainnet'
+  baseUrl?: string;         // Optional: Custom API URL
+})
+```
+
+### Methods
+
+#### `deployToken(params)`
+
+Deploy a new token on VELOCITI.
+
+```typescript
+await client.deployToken({
+  name: string;          // Token name (max 32 chars)
+  symbol: string;        // Token symbol (max 10 chars)
+  description?: string;  // Token description
+  image?: string;        // Image URL (IPFS/Arweave/HTTPS)
+  taxRate?: number;      // Transfer tax 0-10% (default: 5)
+  socials?: {
+    twitter?: string;
+    telegram?: string;
+    website?: string;
+  }
+});
+```
+
+#### `getToken(mintAddress)`
+
+Get token information.
+
+```typescript
+const token = await client.getToken('TokenMintAddress...');
+```
+
+#### `getMyTokens()`
+
+Get all tokens created with your API key.
+
+```typescript
+const tokens = await client.getMyTokens();
+```
+
+#### `claimFees(mintAddress, walletAddress)`
+
+Claim accumulated transfer fees.
+
+```typescript
+const result = await client.claimFees(
+  'TokenMintAddress...',
+  'YourWalletAddress...'
+);
+```
+
+#### `getUnclaimedFees(mintAddress)`
+
+Check unclaimed fees for a token.
+
+```typescript
+const fees = await client.getUnclaimedFees('TokenMintAddress...');
+console.log(`Unclaimed: ${fees.data?.amount} tokens`);
+```
+
+## Rate Limits
+
+| Tier | Requests/Day | Token Deploys/Day | Price |
+|------|--------------|-------------------|-------|
+| Free | 100 | 5 | $0 |
+| Pro | 1,000 | 50 | $49/mo |
+| Enterprise | Unlimited | Unlimited | Contact |
+
+Check your rate limit status:
+
+```typescript
+const rateLimit = client.getRateLimitInfo();
+console.log(`${rateLimit.remaining}/${rateLimit.limit} remaining`);
+```
+
+## Get Your API Key
+
+1. Visit [velociti.fun/developers](https://velociti.fun/developers)
+2. Fill out the access request form
+3. Wait for approval (usually within 24 hours)
+4. Receive your API key via email
+
+## Links
+
+- [VELOCITI Website](https://velociti.fun)
+- [Documentation](https://docs.velociti.fun)
+- [Twitter](https://twitter.com/velocitixyz)
+- [Discord](https://discord.gg/velociti)
+
+## License
+
+MIT

package/dist/client.d.ts

@@ -0,0 +1,98 @@
+/**
+ * VELOCITI SDK Client
+ * Main client class for interacting with the VELOCITI API
+ */
+import { VelocitiConfig, DeployTokenParams, TokenInfo, ClaimFeesResult, ApiResponse, RateLimitInfo, PreparedTransaction, SubmitResult } from './types';
+export declare class VelocitiClient {
+    private apiKey;
+    private baseUrl;
+    private network;
+    private rateLimitInfo;
+    constructor(config: VelocitiConfig);
+    /**
+     * Make an authenticated request to the VELOCITI API
+     */
+    private request;
+    /**
+     * 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'));
+     * ```
+     */
+    prepareTokenDeploy(params: DeployTokenParams): Promise<ApiResponse<PreparedTransaction>>;
+    /**
+     * Submit a signed transaction (Step 2)
+     *
+     * @param signedTransaction - Base64 encoded signed transaction
+     */
+    submitTransaction(signedTransaction: string): Promise<ApiResponse<SubmitResult>>;
+    /**
+     * 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);
+     * });
+     * ```
+     */
+    deployToken(params: DeployTokenParams, signTransaction: (transaction: Uint8Array) => Promise<Uint8Array>): Promise<ApiResponse<SubmitResult>>;
+    /**
+     * Get token information by mint address
+     */
+    getToken(mintAddress: string): Promise<ApiResponse<TokenInfo>>;
+    /**
+     * Get all tokens created with this API key
+     */
+    getMyTokens(): Promise<ApiResponse<TokenInfo[]>>;
+    /**
+     * Prepare fee claim transaction
+     */
+    prepareClaimFees(mintAddress: string, walletAddress: string): Promise<ApiResponse<PreparedTransaction>>;
+    /**
+     * Claim accumulated transfer fees for a token
+     * Combines prepare + sign + submit
+     */
+    claimFees(mintAddress: string, walletAddress: string, signTransaction: (transaction: Uint8Array) => Promise<Uint8Array>): Promise<ApiResponse<ClaimFeesResult>>;
+    /**
+     * Get unclaimed fees for a token
+     */
+    getUnclaimedFees(mintAddress: string): Promise<ApiResponse<{
+        amount: string;
+        valueInSol: number;
+    }>>;
+    /**
+     * Get current rate limit status
+     */
+    getRateLimitInfo(): RateLimitInfo | null;
+    /**
+     * Get the current network
+     */
+    getNetwork(): 'mainnet' | 'devnet';
+}

package/dist/client.js

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * VELOCITI SDK Client
+ * Main client class for interacting with the VELOCITI API
+ */
+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';
+class VelocitiClient {
+    constructor(config) {
+        this.rateLimitInfo = null;
+        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
+     */
+    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}`,
+            };
+        }
+        const data = await response.json();
+        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) {
+        // 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('/deploy/prepare', {
+            method: 'POST',
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * Submit a signed transaction (Step 2)
+     *
+     * @param signedTransaction - Base64 encoded signed transaction
+     */
+    async submitTransaction(signedTransaction) {
+        return this.request('/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, 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 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}` };
+        }
+    }
+    /**
+     * Get token information by mint address
+     */
+    async getToken(mintAddress) {
+        return this.request(`/tokens/${mintAddress}`);
+    }
+    /**
+     * Get all tokens created with this API key
+     */
+    async getMyTokens() {
+        return this.request('/tokens/mine');
+    }
+    /**
+     * Prepare fee claim transaction
+     */
+    async prepareClaimFees(mintAddress, walletAddress) {
+        return this.request('/fees/prepare', {
+            method: 'POST',
+            body: JSON.stringify({ mintAddress, walletAddress }),
+        });
+    }
+    /**
+     * Claim accumulated transfer fees for a token
+     * Combines prepare + sign + submit
+     */
+    async claimFees(mintAddress, walletAddress, signTransaction) {
+        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('/fees/submit', {
+                method: 'POST',
+                body: JSON.stringify({ signedTransaction: signedBase64, mintAddress }),
+            });
+        }
+        catch (error) {
+            return { success: false, error: `Signing failed: ${error.message}` };
+        }
+    }
+    /**
+     * Get unclaimed fees for a token
+     */
+    async getUnclaimedFees(mintAddress) {
+        return this.request(`/fees/${mintAddress}`);
+    }
+    /**
+     * Get current rate limit status
+     */
+    getRateLimitInfo() {
+        return this.rateLimitInfo;
+    }
+    /**
+     * Get the current network
+     */
+    getNetwork() {
+        return this.network;
+    }
+}
+exports.VelocitiClient = VelocitiClient;

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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';

package/dist/index.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * 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
+ * });
+ * ```
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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);

package/dist/types.d.ts

@@ -0,0 +1,118 @@
+/**
+ * VELOCITI SDK Types
+ * TypeScript type definitions for the SDK
+ */
+/** SDK Configuration */
+export interface VelocitiConfig {
+    /** Your API key from velociti.fun/developers */
+    apiKey: string;
+    /** Network to use: 'mainnet' or 'devnet' */
+    network?: 'mainnet' | 'devnet';
+    /** Custom API base URL (optional) */
+    baseUrl?: string;
+}
+/** Token deployment configuration */
+export interface DeployTokenParams {
+    /** Token name (max 32 characters) */
+    name: string;
+    /** Token symbol (max 10 characters) */
+    symbol: string;
+    /** Token description */
+    description?: string;
+    /** Image URL (IPFS, Arweave, or HTTPS) */
+    image?: string;
+    /** Transfer tax rate (0-10%) */
+    taxRate?: number;
+    /** Payer wallet address (required - will sign and pay fees) */
+    payerAddress: string;
+    /** Social links */
+    socials?: {
+        twitter?: string;
+        telegram?: string;
+        website?: string;
+    };
+}
+/** Prepared transaction ready for signing */
+export interface PreparedTransaction {
+    /** Base64 encoded serialized transaction */
+    transaction: string;
+    /** Estimated SOL fee for the transaction */
+    estimatedFee: number;
+    /** Token mint address that will be created */
+    mintAddress: string;
+    /** Message to display to user */
+    message: string;
+    /** Blockhash used (expires after ~60 seconds) */
+    blockhash: string;
+    /** Last valid block height */
+    lastValidBlockHeight: number;
+}
+/** Token information returned from API */
+export interface TokenInfo {
+    /** Token mint address */
+    mintAddress: string;
+    /** Token name */
+    name: string;
+    /** Token symbol */
+    symbol: string;
+    /** Token description */
+    description?: string;
+    /** Token image URL */
+    imageUrl?: string;
+    /** Current price in SOL */
+    priceInSol: number;
+    /** Current price in USD */
+    priceInUsd: number;
+    /** Market cap in USD */
+    marketCapUsd: number;
+    /** Graduation progress (0-100) */
+    progress: number;
+    /** Whether token has graduated to Raydium */
+    isGraduated: boolean;
+    /** Transfer tax rate */
+    taxRate: number;
+    /** Creator wallet address */
+    creator: string;
+    /** Bonding curve PDA */
+    bondingCurvePda: string;
+    /** Total supply */
+    totalSupply: string;
+    /** Created at timestamp */
+    createdAt: string;
+}
+/** Fee claiming result */
+export interface ClaimFeesResult {
+    /** Transaction signature */
+    signature: string;
+    /** Amount claimed in tokens */
+    amountClaimed: string;
+    /** SOL value of claimed fees */
+    valueInSol: number;
+}
+/** Submit signed transaction result */
+export interface SubmitResult {
+    /** Whether submission was successful */
+    success: boolean;
+    /** Transaction signature */
+    signature?: string;
+    /** Token info if deployment confirmed */
+    token?: TokenInfo;
+    /** Error message if failed */
+    error?: string;
+}
+/** API response wrapper */
+export interface ApiResponse<T> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    message?: string;
+}
+/** Rate limit information */
+export interface RateLimitInfo {
+    /** Remaining requests in current window */
+    remaining: number;
+    /** Total limit for current tier */
+    limit: number;
+    /** Reset timestamp (Unix ms) */
+    reset: number;
+}

package/dist/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * VELOCITI SDK Types
+ * TypeScript type definitions for the SDK
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/docs/getting-started.md

@@ -0,0 +1,73 @@
+# 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

@@ -0,0 +1,75 @@
+/**
+ * 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/package.json

@@ -0,0 +1,35 @@
+{
+    "name": "@velociti/sdk",
+    "version": "0.1.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",
+    "scripts": {
+        "build": "tsc",
+        "test": "jest",
+        "prepublishOnly": "npm run build"
+    },
+    "keywords": [
+        "solana",
+        "token",
+        "launchpad",
+        "velociti",
+        "tax-token",
+        "token-2022",
+        "ai-agent"
+    ],
+    "author": "VELOCITI",
+    "license": "MIT",
+    "dependencies": {
+        "@solana/web3.js": "^1.95.0"
+    },
+    "devDependencies": {
+        "@types/node": "^20.0.0",
+        "typescript": "^5.3.0"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/Velociti-Launchpad/velociti-sdk"
+    },
+    "homepage": "https://velociti.fun/developers"
+}

package/src/client.ts

@@ -0,0 +1,260 @@
+/**
+ * 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

@@ -0,0 +1,23 @@
+/**
+ * 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';

package/src/types.ts

@@ -0,0 +1,126 @@
+/**
+ * VELOCITI SDK Types
+ * TypeScript type definitions for the SDK
+ */
+
+/** SDK Configuration */
+export interface VelocitiConfig {
+    /** Your API key from velociti.fun/developers */
+    apiKey: string;
+    /** Network to use: 'mainnet' or 'devnet' */
+    network?: 'mainnet' | 'devnet';
+    /** Custom API base URL (optional) */
+    baseUrl?: string;
+}
+
+/** Token deployment configuration */
+export interface DeployTokenParams {
+    /** Token name (max 32 characters) */
+    name: string;
+    /** Token symbol (max 10 characters) */
+    symbol: string;
+    /** Token description */
+    description?: string;
+    /** Image URL (IPFS, Arweave, or HTTPS) */
+    image?: string;
+    /** Transfer tax rate (0-10%) */
+    taxRate?: number;
+    /** Payer wallet address (required - will sign and pay fees) */
+    payerAddress: string;
+    /** Social links */
+    socials?: {
+        twitter?: string;
+        telegram?: string;
+        website?: string;
+    };
+}
+
+/** Prepared transaction ready for signing */
+export interface PreparedTransaction {
+    /** Base64 encoded serialized transaction */
+    transaction: string;
+    /** Estimated SOL fee for the transaction */
+    estimatedFee: number;
+    /** Token mint address that will be created */
+    mintAddress: string;
+    /** Message to display to user */
+    message: string;
+    /** Blockhash used (expires after ~60 seconds) */
+    blockhash: string;
+    /** Last valid block height */
+    lastValidBlockHeight: number;
+}
+
+/** Token information returned from API */
+export interface TokenInfo {
+    /** Token mint address */
+    mintAddress: string;
+    /** Token name */
+    name: string;
+    /** Token symbol */
+    symbol: string;
+    /** Token description */
+    description?: string;
+    /** Token image URL */
+    imageUrl?: string;
+    /** Current price in SOL */
+    priceInSol: number;
+    /** Current price in USD */
+    priceInUsd: number;
+    /** Market cap in USD */
+    marketCapUsd: number;
+    /** Graduation progress (0-100) */
+    progress: number;
+    /** Whether token has graduated to Raydium */
+    isGraduated: boolean;
+    /** Transfer tax rate */
+    taxRate: number;
+    /** Creator wallet address */
+    creator: string;
+    /** Bonding curve PDA */
+    bondingCurvePda: string;
+    /** Total supply */
+    totalSupply: string;
+    /** Created at timestamp */
+    createdAt: string;
+}
+
+/** Fee claiming result */
+export interface ClaimFeesResult {
+    /** Transaction signature */
+    signature: string;
+    /** Amount claimed in tokens */
+    amountClaimed: string;
+    /** SOL value of claimed fees */
+    valueInSol: number;
+}
+
+/** Submit signed transaction result */
+export interface SubmitResult {
+    /** Whether submission was successful */
+    success: boolean;
+    /** Transaction signature */
+    signature?: string;
+    /** Token info if deployment confirmed */
+    token?: TokenInfo;
+    /** Error message if failed */
+    error?: string;
+}
+
+/** API response wrapper */
+export interface ApiResponse<T> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    message?: string;
+}
+
+/** Rate limit information */
+export interface RateLimitInfo {
+    /** Remaining requests in current window */
+    remaining: number;
+    /** Total limit for current tier */
+    limit: number;
+    /** Reset timestamp (Unix ms) */
+    reset: number;
+}

package/tsconfig.json

@@ -0,0 +1,34 @@
+{
+    "compilerOptions": {
+        "target": "ES2020",
+        "module": "commonjs",
+        "lib": [
+            "ES2020",
+            "DOM"
+        ],
+        "declaration": true,
+        "strict": true,
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "noImplicitThis": true,
+        "alwaysStrict": true,
+        "noUnusedLocals": false,
+        "noUnusedParameters": false,
+        "noImplicitReturns": true,
+        "noFallthroughCasesInSwitch": false,
+        "moduleResolution": "node",
+        "esModuleInterop": true,
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist",
+        "examples"
+    ]
+}