@vibeiao/sdk 0.1.0

package/dist/chunk-TA22XXY4.js

@@ -0,0 +1,224 @@
+// 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 {
+    publicKey: walletLike.publicKey,
+    signTransaction: walletLike.signTransaction,
+    signAllTransactions: walletLike.signAllTransactions
+  };
+};
+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
+};

package/dist/chunk-YON7O6R5.js

@@ -0,0 +1,146 @@
+// src/selfReliance.ts
+var now = () => Date.now();
+var SelfReliance = class {
+  policy;
+  events;
+  state;
+  constructor(config) {
+    this.policy = config.policy;
+    this.events = config.events || {};
+    this.state = {};
+  }
+  update(snapshot) {
+    this.state = {
+      ...this.state,
+      solBalance: snapshot.solBalance ?? this.state.solBalance,
+      openRouterCredits: snapshot.openRouterCredits ?? this.state.openRouterCredits,
+      lastUpdatedAt: snapshot.updatedAt ?? now()
+    };
+    return this.state;
+  }
+  getState() {
+    return { ...this.state };
+  }
+  isLow() {
+    const { solMinBalance, openRouterMinCredits } = this.policy;
+    const solLow = this.state.solBalance !== void 0 && Number.isFinite(solMinBalance) && this.state.solBalance < solMinBalance;
+    const creditsLow = openRouterMinCredits !== void 0 && this.state.openRouterCredits !== void 0 && this.state.openRouterCredits < openRouterMinCredits;
+    return Boolean(solLow || creditsLow);
+  }
+  shouldWarn() {
+    const { solWarnBalance, openRouterWarnCredits, warnIntervalMs = 3e5 } = this.policy;
+    const solWarn = this.state.solBalance !== void 0 && Number.isFinite(solWarnBalance) && this.state.solBalance < solWarnBalance;
+    const creditsWarn = openRouterWarnCredits !== void 0 && this.state.openRouterCredits !== void 0 && this.state.openRouterCredits < openRouterWarnCredits;
+    if (!solWarn && !creditsWarn) return false;
+    const lastWarnAt = this.state.lastWarnAt ?? 0;
+    return now() - lastWarnAt > warnIntervalMs;
+  }
+  async enforce() {
+    if (this.isLow()) {
+      if (this.events.onCritical) {
+        this.events.onCritical(this.getState());
+      }
+      if (this.events.onPersist) {
+        await this.events.onPersist(this.getState());
+      }
+      return this.policy.allowIfLow ? "allow" : "deny";
+    }
+    if (this.shouldWarn()) {
+      this.state.lastWarnAt = now();
+      if (this.events.onWarn) {
+        this.events.onWarn(this.getState());
+      }
+    }
+    return "allow";
+  }
+  guard = async () => {
+    const decision = await this.enforce();
+    return decision === "allow";
+  };
+};
+var createSelfReliancePolicy = (overrides = {}) => ({
+  solMinBalance: 0.01,
+  solWarnBalance: 0.05,
+  openRouterMinCredits: 1,
+  openRouterWarnCredits: 5,
+  allowIfLow: false,
+  warnIntervalMs: 3e5,
+  criticalOnly: false,
+  ...overrides
+});
+var createSurvivalMiddleware = (survival, options = {}) => {
+  const errorStatus = options.errorStatus ?? 402;
+  const errorPayload = options.errorPayload ?? { error: "survival_low_funds" };
+  return async (req, res, next) => {
+    const allowed = await survival.guard();
+    const state = survival.getState();
+    if (!allowed) {
+      if (options.onDeny) {
+        options.onDeny(state);
+      }
+      res.status(errorStatus).json(errorPayload);
+      return;
+    }
+    next();
+  };
+};
+var withSurvival = async (survival, handler, options = {}) => {
+  const allowed = await survival.guard();
+  if (!allowed) {
+    if (options.onDeny) {
+      options.onDeny(survival.getState());
+    }
+    throw new Error("survival_low_funds");
+  }
+  return handler();
+};
+var createSelfRelianceMonitor = (survival, fetchSnapshot, config = {}) => {
+  const intervalMs = config.intervalMs ?? 3e4;
+  let timer = null;
+  let stopped = false;
+  const runOnce = async () => {
+    try {
+      const snapshot = await fetchSnapshot();
+      const state = survival.update(snapshot);
+      if (config.onUpdate) {
+        config.onUpdate(snapshot, state);
+      }
+      await survival.enforce();
+    } catch (err) {
+      if (config.onError) {
+        config.onError(err instanceof Error ? err : new Error("monitor_failed"));
+      }
+    }
+  };
+  const start = async () => {
+    if (timer) return;
+    await runOnce();
+    if (stopped) return;
+    timer = setInterval(runOnce, intervalMs);
+  };
+  const stop = () => {
+    stopped = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  };
+  return { start, stop, runOnce };
+};
+var createAutoSelfReliance = (options) => {
+  const { survival, fetchSnapshot, intervalMs, onUpdate, onError } = options;
+  return createSelfRelianceMonitor(survival, fetchSnapshot, {
+    intervalMs,
+    onUpdate,
+    onError
+  });
+};
+
+export {
+  SelfReliance,
+  createSelfReliancePolicy,
+  createSurvivalMiddleware,
+  withSurvival,
+  createSelfRelianceMonitor,
+  createAutoSelfReliance
+};