@paul.lumberwork/bonding-curve-sdk 1.7.0 → 1.7.2

package/dist/index.mjs

@@ -1,6 +1,7 @@
 import { BN } from '@coral-xyz/anchor';
-import { PublicKey, LAMPORTS_PER_SOL, SystemProgram, Keypair, SYSVAR_RENT_PUBKEY, ComputeBudgetProgram } from '@solana/web3.js';
-import { getAssociatedTokenAddressSync, ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID, getAccount } from '@solana/spl-token';
+import { PublicKey, LAMPORTS_PER_SOL, SystemProgram, Keypair, SYSVAR_RENT_PUBKEY, ComputeBudgetProgram, Ed25519Program, SYSVAR_INSTRUCTIONS_PUBKEY, Transaction } from '@solana/web3.js';
+import { getAssociatedTokenAddressSync, ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID, getAccount, createAssociatedTokenAccountIdempotentInstruction } from '@solana/spl-token';
+import nacl from 'tweetnacl';
 
 // src/sdk/index.ts
 var PROGRAM_ID = new PublicKey("6o7oTqg2CfvcMCJTLNEJsef7c875zGpTvcnFctNAjudL");
@@ -133,6 +134,22 @@ var KickFunSDK = class {
     preInstructions.push(
       ComputeBudgetProgram.setComputeUnitLimit({ units: computeUnits })
     );
+    preInstructions.push(
+      createAssociatedTokenAccountIdempotentInstruction(
+        this.wallet.publicKey,
+        streamerTokenAccount,
+        streamerVaultPda,
+        mint
+      )
+    );
+    preInstructions.push(
+      createAssociatedTokenAccountIdempotentInstruction(
+        this.wallet.publicKey,
+        adminTokenAccount,
+        ADMIN_WALLET,
+        mint
+      )
+    );
     const tx = await this.program.methods.buyTokens(solLamports).accountsPartial({
       contributor: this.wallet.publicKey,
       launchpad: this.launchpadPda,
@@ -616,6 +633,252 @@ var KickFunSDK = class {
     return numerator / denominator;
   }
 };
+var StreamerSDK = class _StreamerSDK {
+  constructor(program, wallet) {
+    this.program = program;
+    this.connection = program.provider.connection;
+    this.wallet = wallet;
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // PDA Derivation Helpers
+  // ═══════════════════════════════════════════════════════════════════════════
+  derivePlatformConfig() {
+    const [pda] = PublicKey.findProgramAddressSync(
+      [Buffer.from("platform_config")],
+      this.program.programId
+    );
+    return pda;
+  }
+  deriveWhitelistEntry(wallet) {
+    const [pda] = PublicKey.findProgramAddressSync(
+      [Buffer.from("whitelist"), wallet.toBuffer()],
+      this.program.programId
+    );
+    return pda;
+  }
+  deriveStreamerRegistration(streamerId) {
+    const [pda] = PublicKey.findProgramAddressSync(
+      [Buffer.from("streamer"), Buffer.from(streamerId)],
+      this.program.programId
+    );
+    return pda;
+  }
+  deriveVault() {
+    const [pda] = PublicKey.findProgramAddressSync(
+      [Buffer.from("vault")],
+      this.program.programId
+    );
+    return pda;
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Helpers
+  // ═══════════════════════════════════════════════════════════════════════════
+  async getSolanaTimestamp() {
+    const slot = await this.connection.getSlot();
+    const blockTime = await this.connection.getBlockTime(slot);
+    if (!blockTime) throw new Error("Failed to get block time");
+    return blockTime;
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Ed25519 Signing Utilities (for browser wallets / external signers)
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * Build the message that the streamer must sign for register_streamer.
+   * The streamer signs this with their wallet (e.g. Phantom signMessage).
+   *
+   * Format: "register_streamer:{streamer_id}:{wallet}:{timestamp}"
+   */
+  buildRegisterMessage(streamerId, streamerWallet, timestamp) {
+    const msg = `register_streamer:${streamerId}:${streamerWallet.toBase58()}:${timestamp}`;
+    return Buffer.from(msg, "utf-8");
+  }
+  /**
+   * Build the message that the streamer must sign for claim_funds.
+   * The streamer signs this with their wallet (e.g. Phantom signMessage).
+   *
+   * Format: "claim_funds:{streamer_id}:{wallet}:{mint}:{token_amount}:{sol_amount}:{timestamp}"
+   */
+  buildClaimMessage(streamerId, streamerWallet, mint, tokenAmount, solAmount, timestamp) {
+    const msg = `claim_funds:${streamerId}:${streamerWallet.toBase58()}:${mint.toBase58()}:${tokenAmount.toString()}:${solAmount.toString()}:${timestamp}`;
+    return Buffer.from(msg, "utf-8");
+  }
+  /**
+   * Create an Ed25519 instruction from an externally-signed signature.
+   * Use this when the streamer signs via browser wallet (Phantom, Solflare, etc.)
+   * instead of exposing a Keypair.
+   *
+   * @param streamerWallet - Public key of the streamer
+   * @param message        - The message bytes (from buildRegisterMessage / buildClaimMessage)
+   * @param signature      - The Ed25519 signature from wallet.signMessage(message)
+   */
+  createEd25519Instruction(streamerWallet, message, signature) {
+    return Ed25519Program.createInstructionWithPublicKey({
+      publicKey: streamerWallet.toBytes(),
+      message,
+      signature
+    });
+  }
+  /**
+   * Sign a message using a Keypair directly (server-side / test usage).
+   * Returns the Ed25519 signature bytes.
+   */
+  static signMessage(message, keypair) {
+    return nacl.sign.detached(message, keypair.secretKey);
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Register Streamer
+  // ═══════════════════════════════════════════════════════════════════════════
+  async registerStreamer(params) {
+    const { streamerId, streamerKeypair } = params;
+    const timestamp = await this.getSolanaTimestamp();
+    const msgBytes = this.buildRegisterMessage(streamerId, streamerKeypair.publicKey, timestamp);
+    const sig = _StreamerSDK.signMessage(msgBytes, streamerKeypair);
+    const ed25519Ix = this.createEd25519Instruction(streamerKeypair.publicKey, msgBytes, sig);
+    const whitelistPda = this.deriveWhitelistEntry(this.wallet.publicKey);
+    const streamerRegPda = this.deriveStreamerRegistration(streamerId);
+    const registerIx = await this.program.methods.registerStreamer(
+      streamerId,
+      streamerKeypair.publicKey,
+      new BN(timestamp)
+    ).accounts({
+      caller: this.wallet.publicKey,
+      whitelistEntry: whitelistPda,
+      streamerRegistration: streamerRegPda,
+      instructionsSysvar: SYSVAR_INSTRUCTIONS_PUBKEY
+    }).instruction();
+    const tx = new Transaction().add(ed25519Ix).add(registerIx);
+    const provider = this.program.provider;
+    const txSignature = await provider.sendAndConfirm(tx);
+    return { txSignature, streamerRegistrationPda: streamerRegPda };
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Claim Funds
+  // ═══════════════════════════════════════════════════════════════════════════
+  async claimFunds(params) {
+    const { streamerId, streamerKeypair, mint, solAmount, tokenAmount } = params;
+    const timestamp = await this.getSolanaTimestamp();
+    const msgBytes = this.buildClaimMessage(streamerId, streamerKeypair.publicKey, mint, tokenAmount, solAmount, timestamp);
+    const sig = _StreamerSDK.signMessage(msgBytes, streamerKeypair);
+    const ed25519Ix = this.createEd25519Instruction(streamerKeypair.publicKey, msgBytes, sig);
+    const whitelistPda = this.deriveWhitelistEntry(this.wallet.publicKey);
+    const streamerRegPda = this.deriveStreamerRegistration(streamerId);
+    const vaultPda = this.deriveVault();
+    const programTokenAccount = getAssociatedTokenAddressSync(
+      mint,
+      vaultPda,
+      true
+    );
+    const streamerTokenAccount = getAssociatedTokenAddressSync(
+      mint,
+      streamerKeypair.publicKey,
+      false
+    );
+    const claimIx = await this.program.methods.claimFunds(streamerId, solAmount, tokenAmount, new BN(timestamp)).accounts({
+      caller: this.wallet.publicKey,
+      whitelistEntry: whitelistPda,
+      streamerRegistration: streamerRegPda,
+      streamerWallet: streamerKeypair.publicKey,
+      vault: vaultPda,
+      mint,
+      programTokenAccount,
+      streamerTokenAccount,
+      instructionsSysvar: SYSVAR_INSTRUCTIONS_PUBKEY
+    }).instruction();
+    const tx = new Transaction().add(ed25519Ix).add(claimIx);
+    const provider = this.program.provider;
+    const txSignature = await provider.sendAndConfirm(tx);
+    return { txSignature };
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Register Streamer (browser wallet — signature from Phantom/Solflare)
+  // ═══════════════════════════════════════════════════════════════════════════
+  async registerStreamerWithSignature(params) {
+    const { streamerId, streamerPublicKey, signature, timestamp } = params;
+    const msgBytes = this.buildRegisterMessage(streamerId, streamerPublicKey, timestamp);
+    const ed25519Ix = this.createEd25519Instruction(streamerPublicKey, msgBytes, signature);
+    const whitelistPda = this.deriveWhitelistEntry(this.wallet.publicKey);
+    const streamerRegPda = this.deriveStreamerRegistration(streamerId);
+    const registerIx = await this.program.methods.registerStreamer(streamerId, streamerPublicKey, new BN(timestamp)).accounts({
+      caller: this.wallet.publicKey,
+      whitelistEntry: whitelistPda,
+      streamerRegistration: streamerRegPda,
+      instructionsSysvar: SYSVAR_INSTRUCTIONS_PUBKEY
+    }).instruction();
+    const tx = new Transaction().add(ed25519Ix).add(registerIx);
+    const provider = this.program.provider;
+    const txSignature = await provider.sendAndConfirm(tx);
+    return { txSignature, streamerRegistrationPda: streamerRegPda };
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Claim Funds (browser wallet — signature from Phantom/Solflare)
+  // ═══════════════════════════════════════════════════════════════════════════
+  async claimFundsWithSignature(params) {
+    const { streamerId, streamerPublicKey, mint, solAmount, tokenAmount, signature, timestamp } = params;
+    const msgBytes = this.buildClaimMessage(streamerId, streamerPublicKey, mint, tokenAmount, solAmount, timestamp);
+    const ed25519Ix = this.createEd25519Instruction(streamerPublicKey, msgBytes, signature);
+    const whitelistPda = this.deriveWhitelistEntry(this.wallet.publicKey);
+    const streamerRegPda = this.deriveStreamerRegistration(streamerId);
+    const vaultPda = this.deriveVault();
+    const programTokenAccount = getAssociatedTokenAddressSync(mint, vaultPda, true);
+    const streamerTokenAccount = getAssociatedTokenAddressSync(mint, streamerPublicKey, false);
+    const claimIx = await this.program.methods.claimFunds(streamerId, solAmount, tokenAmount, new BN(timestamp)).accounts({
+      caller: this.wallet.publicKey,
+      whitelistEntry: whitelistPda,
+      streamerRegistration: streamerRegPda,
+      streamerWallet: streamerPublicKey,
+      vault: vaultPda,
+      mint,
+      programTokenAccount,
+      streamerTokenAccount,
+      instructionsSysvar: SYSVAR_INSTRUCTIONS_PUBKEY
+    }).instruction();
+    const tx = new Transaction().add(ed25519Ix).add(claimIx);
+    const provider = this.program.provider;
+    const txSignature = await provider.sendAndConfirm(tx);
+    return { txSignature };
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Read State
+  // ═══════════════════════════════════════════════════════════════════════════
+  async getStreamerRegistration(streamerId) {
+    const pda = this.deriveStreamerRegistration(streamerId);
+    try {
+      const account = await this.program.account.streamerRegistration.fetch(pda);
+      return {
+        streamerId: account.streamerId,
+        wallet: account.wallet,
+        verifiedAt: account.verifiedAt.toNumber(),
+        registeredBy: account.registeredBy,
+        createdAt: account.createdAt.toNumber()
+      };
+    } catch {
+      return null;
+    }
+  }
+  async isWhitelisted(wallet) {
+    const pda = this.deriveWhitelistEntry(wallet);
+    try {
+      const account = await this.program.account.whitelistEntry.fetch(pda);
+      return account.active;
+    } catch {
+      return false;
+    }
+  }
+  async getVaultBalance(mint) {
+    const vaultPda = this.deriveVault();
+    const sol = BigInt(await this.connection.getBalance(vaultPda));
+    let tokens = 0n;
+    if (mint) {
+      const ata = getAssociatedTokenAddressSync(mint, vaultPda, true);
+      try {
+        const account = await getAccount(this.connection, ata);
+        tokens = account.amount;
+      } catch {
+      }
+    }
+    return { sol, tokens };
+  }
+};
 function formatTokens(raw) {
   const tokens = Number(raw) / 10 ** TOKEN_DECIMALS;
   return tokens.toLocaleString(void 0, { maximumFractionDigits: 2 });
@@ -631,6 +894,6 @@ function parseTokens(tokens) {
   return BigInt(Math.floor(tokens * 10 ** TOKEN_DECIMALS));
 }
 
-export { ADMIN_WALLET, CURVE_PERCENT, FEE_BPS, K_SCALE, KickFunSDK, LAMPORTS, LP_PERCENT, METADATA_PROGRAM_ID, PROGRAM_ID, STREAMER_PROGRAM_ID, TOKEN_DECIMALS, TREASURY_PERCENT, formatSol, formatTokens, parseSol, parseTokens };
+export { ADMIN_WALLET, CURVE_PERCENT, FEE_BPS, K_SCALE, KickFunSDK, LAMPORTS, LP_PERCENT, METADATA_PROGRAM_ID, PROGRAM_ID, STREAMER_PROGRAM_ID, StreamerSDK, TOKEN_DECIMALS, TREASURY_PERCENT, formatSol, formatTokens, parseSol, parseTokens };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map