@vibeiao/sdk 0.1.0

package/dist/chunk-CJAFFQLN.js

@@ -0,0 +1,220 @@
+// src/solana.ts
+import { AnchorProvider, Program } from "@coral-xyz/anchor";
+import {
+  LAMPORTS_PER_SOL,
+  PublicKey,
+  SystemProgram
+} from "@solana/web3.js";
+import BN from "bn.js";
+import { VIBEIAO_IDL } from "@vibeiao/shared";
+var toPublicKey = (value) => value instanceof PublicKey ? value : new PublicKey(value);
+var toAnchorWallet = (wallet) => {
+  if ("secretKey" in wallet) {
+    const keypair = wallet;
+    return {
+      publicKey: keypair.publicKey,
+      signTransaction: async (tx) => {
+        if (tx && typeof tx === "object") {
+          const maybeLegacy = tx;
+          const maybeVersioned = tx;
+          if (typeof maybeLegacy.partialSign === "function") {
+            maybeLegacy.partialSign(keypair);
+          } else if (typeof maybeVersioned.sign === "function") {
+            maybeVersioned.sign([keypair]);
+          }
+        }
+        return tx;
+      },
+      signAllTransactions: async (txs) => {
+        txs.forEach((tx) => {
+          if (tx && typeof tx === "object") {
+            const maybeLegacy = tx;
+            const maybeVersioned = tx;
+            if (typeof maybeLegacy.partialSign === "function") {
+              maybeLegacy.partialSign(keypair);
+            } else if (typeof maybeVersioned.sign === "function") {
+              maybeVersioned.sign([keypair]);
+            }
+          }
+        });
+        return txs;
+      }
+    };
+  }
+  const walletLike = wallet;
+  if (typeof walletLike.signAllTransactions !== "function") {
+    return {
+      publicKey: walletLike.publicKey,
+      signTransaction: walletLike.signTransaction,
+      signAllTransactions: async (txs) => {
+        const signed = [];
+        for (const tx of txs) {
+          signed.push(await walletLike.signTransaction(tx));
+        }
+        return signed;
+      }
+    };
+  }
+  return walletLike;
+};
+var toLamports = (sol) => new BN(Math.round(sol * LAMPORTS_PER_SOL));
+var toSol = (lamports) => Number(lamports) / LAMPORTS_PER_SOL;
+var deriveListingPda = (creator, seed, programId) => PublicKey.findProgramAddressSync([
+  Buffer.from("listing"),
+  creator.toBuffer(),
+  Buffer.from(seed)
+], programId);
+var deriveTicketReceiptPda = (listing, buyer, programId) => PublicKey.findProgramAddressSync([
+  Buffer.from("ticket"),
+  listing.toBuffer(),
+  buyer.toBuffer()
+], programId);
+var deriveConfigPda = (programId) => PublicKey.findProgramAddressSync([Buffer.from("config")], programId);
+var fetchSolBalance = async (connection, wallet) => {
+  const pubkey = toPublicKey(wallet);
+  const lamports = await connection.getBalance(pubkey, "confirmed");
+  return toSol(lamports);
+};
+var fetchTokenBalance = async (connection, wallet, mint) => {
+  const owner = toPublicKey(wallet);
+  const mintKey = toPublicKey(mint);
+  const response = await connection.getTokenAccountsByOwner(owner, { mint: mintKey });
+  const account = response.value[0];
+  if (!account) return 0;
+  const balance = await connection.getTokenAccountBalance(account.pubkey, "confirmed");
+  return Number(balance.value.uiAmount || 0);
+};
+var fetchTokenBalances = async (connection, wallet, mints) => {
+  const owner = toPublicKey(wallet);
+  const results = {};
+  await Promise.all(
+    mints.map(async (mint) => {
+      const mintKey = toPublicKey(mint);
+      const response = await connection.getTokenAccountsByOwner(owner, { mint: mintKey });
+      const account = response.value[0];
+      if (!account) {
+        results[mintKey.toBase58()] = 0;
+        return;
+      }
+      const balance = await connection.getTokenAccountBalance(account.pubkey, "confirmed");
+      results[mintKey.toBase58()] = Number(balance.value.uiAmount || 0);
+    })
+  );
+  return results;
+};
+var VibePayments = class {
+  connection;
+  wallet;
+  programId;
+  commitment;
+  constructor(options) {
+    this.connection = options.connection;
+    this.wallet = toAnchorWallet(options.wallet);
+    this.programId = toPublicKey(options.programId);
+    this.commitment = options.commitment || "confirmed";
+  }
+  getProgramId() {
+    return this.programId.toBase58();
+  }
+  getProgram() {
+    const provider = new AnchorProvider(this.connection, this.wallet, {
+      preflightCommitment: this.commitment
+    });
+    return new Program(VIBEIAO_IDL, this.programId, provider);
+  }
+  async fetchProtocolConfig() {
+    const program = this.getProgram();
+    const [config] = deriveConfigPda(this.programId);
+    const data = await program.account.protocolConfig.fetch(config);
+    return {
+      platformTreasury: data.platformTreasury.toBase58(),
+      buybackTreasury: data.buybackTreasury.toBase58()
+    };
+  }
+  getTicketReceiptAddress(listingAccount, buyer) {
+    const listingPubkey = new PublicKey(listingAccount);
+    const buyerKey = buyer ?? this.wallet.publicKey;
+    const [receipt] = deriveTicketReceiptPda(listingPubkey, buyerKey, this.programId);
+    return receipt.toBase58();
+  }
+  async purchaseTicket(input) {
+    const program = this.getProgram();
+    const listingPubkey = new PublicKey(input.listingAccount);
+    const [ticketReceipt] = deriveTicketReceiptPda(listingPubkey, this.wallet.publicKey, this.programId);
+    const [config] = deriveConfigPda(this.programId);
+    let platformTreasury = input.platformTreasury;
+    let buybackTreasury = input.buybackTreasury;
+    if (!platformTreasury || !buybackTreasury) {
+      const protocol = await this.fetchProtocolConfig();
+      platformTreasury = platformTreasury || protocol.platformTreasury;
+      buybackTreasury = buybackTreasury || protocol.buybackTreasury;
+    }
+    if (!platformTreasury || !buybackTreasury) {
+      throw new Error("protocol_config_missing");
+    }
+    return program.methods.purchaseTicket().accounts({
+      buyer: this.wallet.publicKey,
+      listing: listingPubkey,
+      config,
+      creator: new PublicKey(input.creatorWallet),
+      revenueWallet: new PublicKey(input.revenueWallet),
+      platformTreasury: new PublicKey(platformTreasury),
+      buybackTreasury: new PublicKey(buybackTreasury),
+      ticketReceipt,
+      systemProgram: SystemProgram.programId
+    }).rpc();
+  }
+  async purchaseTicketForListing(input) {
+    const listing = input.listing;
+    const listingAccount = listing.chain_listing_account;
+    const creatorWallet = listing.creator_wallet_address;
+    const revenueWallet = listing.revenue_wallet_address || listing.creator_wallet_address;
+    if (!listingAccount) {
+      throw new Error("listing_missing_chain_account");
+    }
+    if (!creatorWallet) {
+      throw new Error("listing_missing_creator_wallet");
+    }
+    if (!revenueWallet) {
+      throw new Error("listing_missing_revenue_wallet");
+    }
+    return this.purchaseTicket({
+      listingAccount,
+      creatorWallet,
+      revenueWallet,
+      platformTreasury: input.platformTreasury,
+      buybackTreasury: input.buybackTreasury
+    });
+  }
+  async redeemTicket(listingAccount) {
+    const program = this.getProgram();
+    const listingPubkey = new PublicKey(listingAccount);
+    const [ticketReceipt] = deriveTicketReceiptPda(listingPubkey, this.wallet.publicKey, this.programId);
+    return program.methods.redeemTicket().accounts({
+      buyer: this.wallet.publicKey,
+      listing: listingPubkey,
+      ticketReceipt
+    }).rpc();
+  }
+  async updateTicketPrice(listingAccount, priceSol) {
+    const program = this.getProgram();
+    const listingPubkey = new PublicKey(listingAccount);
+    const lamports = toLamports(priceSol);
+    return program.methods.updateTicketPrice(lamports).accounts({
+      creator: this.wallet.publicKey,
+      listing: listingPubkey
+    }).rpc();
+  }
+};
+
+export {
+  toLamports,
+  toSol,
+  deriveListingPda,
+  deriveTicketReceiptPda,
+  deriveConfigPda,
+  fetchSolBalance,
+  fetchTokenBalance,
+  fetchTokenBalances,
+  VibePayments
+};