@clawdvault/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,631 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ClawdVaultClient: () => ClawdVaultClient,
+  DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
+  Keypair: () => import_web32.Keypair,
+  KeypairSigner: () => KeypairSigner,
+  PROGRAM_ID: () => PROGRAM_ID,
+  PhantomSigner: () => PhantomSigner,
+  PublicKey: () => import_web32.PublicKey,
+  createAuthSignature: () => createAuthSignature,
+  createClient: () => createClient,
+  signAndSerialize: () => signAndSerialize,
+  verifySignature: () => verifySignature
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/wallet.ts
+var import_web3 = require("@solana/web3.js");
+var import_bs58 = __toESM(require("bs58"));
+var KeypairSigner = class _KeypairSigner {
+  constructor(keypairOrSecretKey) {
+    if (keypairOrSecretKey instanceof import_web3.Keypair) {
+      this._keypair = keypairOrSecretKey;
+    } else if (typeof keypairOrSecretKey === "string") {
+      if (keypairOrSecretKey.startsWith("[")) {
+        const secretKey = new Uint8Array(JSON.parse(keypairOrSecretKey));
+        this._keypair = import_web3.Keypair.fromSecretKey(secretKey);
+      } else {
+        const secretKey = import_bs58.default.decode(keypairOrSecretKey);
+        this._keypair = import_web3.Keypair.fromSecretKey(secretKey);
+      }
+    } else {
+      this._keypair = import_web3.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 import_web3.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 = import_web3.VersionedTransaction.deserialize(txBuffer);
+    const signedTx = await signer.signTransaction(versionedTx);
+    return Buffer.from(signedTx.serialize()).toString("base64");
+  } catch {
+    const legacyTx = import_web3.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: import_bs58.default.encode(signatureBytes),
+    wallet: signer.publicKey.toBase58()
+  };
+}
+function verifySignature(message, signature, publicKey) {
+  try {
+    const messageBytes = new TextEncoder().encode(message);
+    const signatureBytes = import_bs58.default.decode(signature);
+    const pubkey = new import_web3.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
+var import_web32 = require("@solana/web3.js");
+var PROGRAM_ID = "GUyF2TVe32Cid4iGVt2F6wPYDhLSVmTUZBj2974outYM";
+var DEFAULT_BASE_URL = "https://clawdvault.com/api";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ClawdVaultClient,
+  DEFAULT_BASE_URL,
+  Keypair,
+  KeypairSigner,
+  PROGRAM_ID,
+  PhantomSigner,
+  PublicKey,
+  createAuthSignature,
+  createClient,
+  signAndSerialize,
+  verifySignature
+});