@clawdvault/sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,596 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/wallet.ts
+import {
+  Keypair,
+  PublicKey,
+  Transaction,
+  VersionedTransaction
+} from "@solana/web3.js";
+import bs58 from "bs58";
+var KeypairSigner = class _KeypairSigner {
+  constructor(keypairOrSecretKey) {
+    if (keypairOrSecretKey instanceof Keypair) {
+      this._keypair = keypairOrSecretKey;
+    } else if (typeof keypairOrSecretKey === "string") {
+      if (keypairOrSecretKey.startsWith("[")) {
+        const secretKey = new Uint8Array(JSON.parse(keypairOrSecretKey));
+        this._keypair = Keypair.fromSecretKey(secretKey);
+      } else {
+        const secretKey = bs58.decode(keypairOrSecretKey);
+        this._keypair = Keypair.fromSecretKey(secretKey);
+      }
+    } else {
+      this._keypair = Keypair.fromSecretKey(keypairOrSecretKey);
+    }
+  }
+  get publicKey() {
+    return this._keypair.publicKey;
+  }
+  /**
+   * Get the underlying Keypair (use with caution)
+   */
+  get keypair() {
+    return this._keypair;
+  }
+  async signTransaction(tx) {
+    if (tx instanceof Transaction) {
+      tx.sign(this._keypair);
+    } else {
+      tx.sign([this._keypair]);
+    }
+    return tx;
+  }
+  async signMessage(message) {
+    const nacl = __require("tweetnacl");
+    const signature = nacl.sign.detached(message, this._keypair.secretKey);
+    return signature;
+  }
+  /**
+   * Load keypair from file path (e.g., Solana CLI wallet)
+   */
+  static fromFile(path) {
+    const fs = __require("fs");
+    const data = fs.readFileSync(path, "utf-8");
+    const secretKey = new Uint8Array(JSON.parse(data));
+    return new _KeypairSigner(secretKey);
+  }
+  /**
+   * Load from environment variable
+   */
+  static fromEnv(envVar = "SOLANA_PRIVATE_KEY") {
+    const key = process.env[envVar];
+    if (!key) {
+      throw new Error(`Environment variable ${envVar} not set`);
+    }
+    return new _KeypairSigner(key);
+  }
+};
+var PhantomSigner = class _PhantomSigner {
+  constructor(phantom) {
+    this.phantom = phantom;
+  }
+  get publicKey() {
+    return this.phantom.publicKey;
+  }
+  async signTransaction(tx) {
+    return this.phantom.signTransaction(tx);
+  }
+  async signMessage(message) {
+    const { signature } = await this.phantom.signMessage(message);
+    return signature;
+  }
+  /**
+   * Get Phantom from window object (browser only)
+   */
+  static async fromWindow() {
+    if (typeof window === "undefined") {
+      throw new Error("PhantomSigner.fromWindow() only works in browser");
+    }
+    const phantom = window.phantom?.solana;
+    if (!phantom) {
+      throw new Error("Phantom wallet not found. Please install Phantom extension.");
+    }
+    if (!phantom.isConnected) {
+      await phantom.connect();
+    }
+    return new _PhantomSigner(phantom);
+  }
+};
+async function signAndSerialize(transaction, signer) {
+  const txBuffer = Buffer.from(transaction, "base64");
+  try {
+    const versionedTx = VersionedTransaction.deserialize(txBuffer);
+    const signedTx = await signer.signTransaction(versionedTx);
+    return Buffer.from(signedTx.serialize()).toString("base64");
+  } catch {
+    const legacyTx = Transaction.from(txBuffer);
+    const signedTx = await signer.signTransaction(legacyTx);
+    return Buffer.from(signedTx.serialize()).toString("base64");
+  }
+}
+async function createAuthSignature(signer, payload) {
+  const message = JSON.stringify(payload);
+  const messageBytes = new TextEncoder().encode(message);
+  const signatureBytes = await signer.signMessage(messageBytes);
+  return {
+    signature: bs58.encode(signatureBytes),
+    wallet: signer.publicKey.toBase58()
+  };
+}
+function verifySignature(message, signature, publicKey) {
+  try {
+    const messageBytes = new TextEncoder().encode(message);
+    const signatureBytes = bs58.decode(signature);
+    const pubkey = new PublicKey(publicKey);
+    const nacl = __require("tweetnacl");
+    return nacl.sign.detached.verify(messageBytes, signatureBytes, pubkey.toBytes());
+  } catch {
+    return false;
+  }
+}
+
+// src/client.ts
+var ClawdVaultClient = class {
+  constructor(config = {}) {
+    this.baseUrl = config.baseUrl?.replace(/\/$/, "") || "https://clawdvault.com/api";
+    this.signer = config.signer;
+    this.sessionToken = config.sessionToken;
+    this.onError = config.onError;
+  }
+  /**
+   * Set the wallet signer for authenticated operations
+   */
+  setSigner(signer) {
+    this.signer = signer;
+  }
+  /**
+   * Set session token for authenticated operations
+   */
+  setSessionToken(token) {
+    this.sessionToken = token;
+  }
+  /**
+   * Get wallet address
+   */
+  getWalletAddress() {
+    return this.signer?.publicKey.toBase58() ?? null;
+  }
+  async request(method, path, options = {}) {
+    const { params, body, auth, formData } = options;
+    let url = `${this.baseUrl}${path}`;
+    if (params) {
+      const searchParams = new URLSearchParams();
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0 && value !== null) {
+          searchParams.set(key, String(value));
+        }
+      }
+      const qs = searchParams.toString();
+      if (qs) url += `?${qs}`;
+    }
+    const headers = {};
+    if (auth) {
+      if (this.sessionToken) {
+        headers["Authorization"] = `Bearer ${this.sessionToken}`;
+      } else if (this.signer && body) {
+        const { signature, wallet } = await createAuthSignature(this.signer, body);
+        headers["X-Wallet"] = wallet;
+        headers["X-Signature"] = signature;
+      }
+    }
+    let requestBody;
+    if (formData) {
+      requestBody = formData;
+    } else if (body) {
+      headers["Content-Type"] = "application/json";
+      requestBody = JSON.stringify(body);
+    }
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: requestBody
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: response.statusText }));
+      const err = new Error(error.error || error.message || `HTTP ${response.status}`);
+      err.status = response.status;
+      err.response = error;
+      this.onError?.(err);
+      throw err;
+    }
+    return response.json();
+  }
+  // ============ Token Operations ============
+  /**
+   * List tokens with optional filters
+   */
+  async listTokens(params = {}) {
+    return this.request("GET", "/tokens", { params });
+  }
+  /**
+   * Get token details
+   */
+  async getToken(mint) {
+    return this.request("GET", `/tokens/${mint}`);
+  }
+  /**
+   * Get token metadata (Metaplex format)
+   */
+  async getMetadata(mint) {
+    return this.request("GET", `/metadata/${mint}`);
+  }
+  /**
+   * Prepare token creation (step 1)
+   */
+  async prepareCreate(params) {
+    return this.request("POST", "/token/prepare-create", { body: params });
+  }
+  /**
+   * Execute token creation (step 2)
+   */
+  async executeCreate(params) {
+    return this.request("POST", "/token/execute-create", { body: params });
+  }
+  /**
+   * Create token with automatic signing
+   * Combines prepare + sign + execute in one call
+   */
+  async createToken(params) {
+    if (!this.signer) {
+      throw new Error("Signer required for createToken");
+    }
+    const wallet = this.signer.publicKey.toBase58();
+    const prepared = await this.prepareCreate({
+      creator: wallet,
+      name: params.name,
+      symbol: params.symbol,
+      initialBuy: params.initialBuy
+    });
+    const signedTx = await signAndSerialize(prepared.transaction, this.signer);
+    return this.executeCreate({
+      signedTransaction: signedTx,
+      mint: prepared.mint,
+      creator: wallet,
+      name: params.name,
+      symbol: params.symbol,
+      description: params.description,
+      image: params.image,
+      twitter: params.twitter,
+      telegram: params.telegram,
+      website: params.website
+    });
+  }
+  // ============ Trading Operations ============
+  /**
+   * Get price quote
+   */
+  async getQuote(params) {
+    return this.request("GET", "/trade", { params });
+  }
+  /**
+   * Prepare trade transaction (step 1)
+   */
+  async prepareTrade(params) {
+    return this.request("POST", "/trade/prepare", { body: params });
+  }
+  /**
+   * Execute trade (step 2)
+   */
+  async executeTrade(params) {
+    return this.request("POST", "/trade/execute", { body: params });
+  }
+  /**
+   * Buy tokens with automatic signing
+   */
+  async buy(mint, solAmount, slippage = 0.01) {
+    if (!this.signer) {
+      throw new Error("Signer required for buy");
+    }
+    const wallet = this.signer.publicKey.toBase58();
+    const prepared = await this.prepareTrade({
+      mint,
+      type: "buy",
+      amount: solAmount,
+      wallet,
+      slippage
+    });
+    const signedTx = await signAndSerialize(prepared.transaction, this.signer);
+    return this.executeTrade({
+      signedTransaction: signedTx,
+      mint,
+      type: "buy",
+      wallet
+    });
+  }
+  /**
+   * Sell tokens with automatic signing
+   */
+  async sell(mint, tokenAmount, slippage = 0.01) {
+    if (!this.signer) {
+      throw new Error("Signer required for sell");
+    }
+    const wallet = this.signer.publicKey.toBase58();
+    const prepared = await this.prepareTrade({
+      mint,
+      type: "sell",
+      amount: tokenAmount,
+      wallet,
+      slippage
+    });
+    const signedTx = await signAndSerialize(prepared.transaction, this.signer);
+    return this.executeTrade({
+      signedTransaction: signedTx,
+      mint,
+      type: "sell",
+      wallet
+    });
+  }
+  /**
+   * Sell percentage of token holdings
+   */
+  async sellPercent(mint, percent, slippage = 0.01) {
+    if (!this.signer) {
+      throw new Error("Signer required for sellPercent");
+    }
+    const wallet = this.signer.publicKey.toBase58();
+    const { balance } = await this.getBalance(wallet, mint);
+    if (balance <= 0) {
+      throw new Error("No tokens to sell");
+    }
+    const tokenAmount = balance * (percent / 100);
+    return this.sell(mint, tokenAmount, slippage);
+  }
+  // ============ Price Data ============
+  /**
+   * Get trade history
+   */
+  async getTrades(params) {
+    return this.request("GET", "/trades", { params });
+  }
+  /**
+   * Get OHLCV candles
+   */
+  async getCandles(params) {
+    return this.request("GET", "/candles", { params });
+  }
+  /**
+   * Get on-chain stats
+   */
+  async getStats(mint) {
+    return this.request("GET", "/stats", { params: { mint } });
+  }
+  /**
+   * Get top holders
+   */
+  async getHolders(mint, creator) {
+    return this.request("GET", "/holders", { params: { mint, creator } });
+  }
+  /**
+   * Get wallet token balance
+   */
+  async getBalance(wallet, mint) {
+    return this.request("GET", "/balance", { params: { wallet, mint } });
+  }
+  /**
+   * Get my balance for a token
+   */
+  async getMyBalance(mint) {
+    if (!this.signer) {
+      throw new Error("Signer required for getMyBalance");
+    }
+    return this.getBalance(this.signer.publicKey.toBase58(), mint);
+  }
+  /**
+   * Get SOL/USD price
+   */
+  async getSolPrice() {
+    return this.request("GET", "/sol-price");
+  }
+  // ============ Graduation / Jupiter ============
+  /**
+   * Check graduation status
+   */
+  async getGraduationStatus(mint) {
+    return this.request("GET", "/graduate", { params: { mint } });
+  }
+  /**
+   * Check Jupiter availability
+   */
+  async getJupiterStatus(mint) {
+    return this.request("GET", "/trade/jupiter", { params: { mint } });
+  }
+  /**
+   * Get Jupiter swap quote
+   */
+  async getJupiterQuote(params) {
+    return this.request("POST", "/trade/jupiter", { body: params });
+  }
+  /**
+   * Execute Jupiter swap
+   */
+  async executeJupiterSwap(params) {
+    return this.request("POST", "/trade/jupiter/execute", { body: params });
+  }
+  /**
+   * Buy graduated token via Jupiter
+   */
+  async buyJupiter(mint, solAmount, slippageBps = 50) {
+    if (!this.signer) {
+      throw new Error("Signer required for buyJupiter");
+    }
+    const wallet = this.signer.publicKey.toBase58();
+    const lamports = Math.floor(solAmount * 1e9);
+    const quote = await this.getJupiterQuote({
+      mint,
+      action: "buy",
+      amount: lamports.toString(),
+      userPublicKey: wallet,
+      slippageBps
+    });
+    const signedTx = await signAndSerialize(quote.transaction, this.signer);
+    return this.executeJupiterSwap({
+      mint,
+      signedTransaction: signedTx,
+      type: "buy",
+      wallet
+    });
+  }
+  /**
+   * Sell graduated token via Jupiter
+   */
+  async sellJupiter(mint, tokenAmount, slippageBps = 50) {
+    if (!this.signer) {
+      throw new Error("Signer required for sellJupiter");
+    }
+    const wallet = this.signer.publicKey.toBase58();
+    const quote = await this.getJupiterQuote({
+      mint,
+      action: "sell",
+      amount: Math.floor(tokenAmount * 1e6).toString(),
+      // Assuming 6 decimals
+      userPublicKey: wallet,
+      slippageBps
+    });
+    const signedTx = await signAndSerialize(quote.transaction, this.signer);
+    return this.executeJupiterSwap({
+      mint,
+      signedTransaction: signedTx,
+      type: "sell",
+      wallet
+    });
+  }
+  /**
+   * Smart buy - automatically routes to bonding curve or Jupiter
+   */
+  async smartBuy(mint, solAmount, slippage = 0.01) {
+    const status = await this.getJupiterStatus(mint);
+    if (status.graduated) {
+      return this.buyJupiter(mint, solAmount, Math.floor(slippage * 1e4));
+    }
+    return this.buy(mint, solAmount, slippage);
+  }
+  /**
+   * Smart sell - automatically routes to bonding curve or Jupiter
+   */
+  async smartSell(mint, tokenAmount, slippage = 0.01) {
+    const status = await this.getJupiterStatus(mint);
+    if (status.graduated) {
+      return this.sellJupiter(mint, tokenAmount, Math.floor(slippage * 1e4));
+    }
+    return this.sell(mint, tokenAmount, slippage);
+  }
+  // ============ Chat ============
+  /**
+   * Get chat messages
+   */
+  async getChat(params) {
+    return this.request("GET", "/chat", { params });
+  }
+  /**
+   * Send chat message
+   */
+  async sendChat(params) {
+    return this.request("POST", "/chat", { body: params, auth: true });
+  }
+  /**
+   * Add reaction
+   */
+  async addReaction(messageId, emoji) {
+    await this.request("POST", "/reactions", {
+      body: { messageId, emoji },
+      auth: true
+    });
+  }
+  /**
+   * Remove reaction
+   */
+  async removeReaction(messageId, emoji) {
+    await this.request("DELETE", "/reactions", {
+      params: { messageId, emoji },
+      auth: true
+    });
+  }
+  // ============ User / Auth ============
+  /**
+   * Get user profile
+   */
+  async getProfile(wallet) {
+    return this.request("GET", "/profile", { params: { wallet } });
+  }
+  /**
+   * Update profile
+   */
+  async updateProfile(params) {
+    await this.request("POST", "/profile", { body: params, auth: true });
+  }
+  /**
+   * Create session token
+   */
+  async createSession() {
+    return this.request("POST", "/auth/session", { body: {}, auth: true });
+  }
+  /**
+   * Validate session token
+   */
+  async validateSession() {
+    return this.request("GET", "/auth/session", { auth: true });
+  }
+  // ============ Uploads ============
+  /**
+   * Upload image file
+   */
+  async uploadImage(file, filename = "image.png") {
+    const formData = new FormData();
+    if (file instanceof Blob) {
+      formData.append("file", file, filename);
+    } else {
+      const blob = new Blob([file]);
+      formData.append("file", blob, filename);
+    }
+    return this.request("POST", "/upload", { formData });
+  }
+  /**
+   * Upload image from file path (Node.js only)
+   */
+  async uploadImageFromPath(filePath) {
+    const fs = __require("fs");
+    const path = __require("path");
+    const buffer = fs.readFileSync(filePath);
+    const filename = path.basename(filePath);
+    return this.uploadImage(buffer, filename);
+  }
+  // ============ Network ============
+  /**
+   * Get network status
+   */
+  async getNetworkStatus() {
+    return this.request("GET", "/network");
+  }
+};
+function createClient(config) {
+  return new ClawdVaultClient(config);
+}
+
+// src/index.ts
+import { PublicKey as PublicKey2, Keypair as Keypair2 } from "@solana/web3.js";
+var PROGRAM_ID = "GUyF2TVe32Cid4iGVt2F6wPYDhLSVmTUZBj2974outYM";
+var DEFAULT_BASE_URL = "https://clawdvault.com/api";
+export {
+  ClawdVaultClient,
+  DEFAULT_BASE_URL,
+  Keypair2 as Keypair,
+  KeypairSigner,
+  PROGRAM_ID,
+  PhantomSigner,
+  PublicKey2 as PublicKey,
+  createAuthSignature,
+  createClient,
+  signAndSerialize,
+  verifySignature
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@clawdvault/sdk",
+  "version": "0.1.0",
+  "description": "TypeScript SDK for ClawdVault - Solana token launchpad",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "test": "vitest run",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@solana/web3.js": "^1.91.0",
+    "@solana/spl-token": "^0.4.0",
+    "bs58": "^5.0.0",
+    "tweetnacl": "^1.0.3"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.0"
+  },
+  "keywords": [
+    "clawdvault",
+    "solana",
+    "token",
+    "launchpad",
+    "pump",
+    "sdk"
+  ],
+  "author": "ClawdVault",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/clawdvault/clawdvault-sdk"
+  },
+  "homepage": "https://clawdvault.com"
+}