@microslop/ping-directory-sdk 0.1.5

package/src/pda.js

@@ -0,0 +1,75 @@
+// PDA finders. Each returns [PublicKey, bump].
+
+import { PublicKey } from '@solana/web3.js';
+import { PROGRAM_ID, Seeds } from './constants.js';
+import { u32LE, u64LE } from './encoding.js';
+
+const seedBytes = (s) => new TextEncoder().encode(s);
+
+export function findPDA(seeds) {
+  return PublicKey.findProgramAddressSync(seeds, PROGRAM_ID);
+}
+
+export const findConfigPDA = () =>
+  findPDA([seedBytes(Seeds.CONFIG)]);
+
+export const findUsernamePDA = (username) =>
+  findPDA([seedBytes(Seeds.USERNAME), new TextEncoder().encode(username)]);
+
+// Combined ed25519 metadata PDA — replaces ReverseLookup + CompromisedKey.
+// Holds both `bound_username` (current binding) and `compromised_at`
+// (revocation marker), in one PDA per ed25519 key.
+export const findEd25519AccountPDA = (ed25519Pubkey) => {
+  const bytes = ed25519Pubkey instanceof PublicKey ? ed25519Pubkey.toBytes() : ed25519Pubkey;
+  return findPDA([seedBytes(Seeds.ED25519), bytes]);
+};
+
+export const findNoncePDA = (nonce) =>
+  findPDA([seedBytes(Seeds.NONCE), nonce]);
+
+export const findGracePeriodPDA = (username) =>
+  findPDA([seedBytes(Seeds.GRACE), new TextEncoder().encode(username)]);
+
+export const findSaleListingPDA = (username) =>
+  findPDA([seedBytes(Seeds.SALE), new TextEncoder().encode(username)]);
+
+export const findReferralBalancePDA = (referrerPubkey) => {
+  const key = referrerPubkey ?? PublicKey.default;
+  const bytes = key instanceof PublicKey ? key.toBytes() : new Uint8Array(key);
+  return findPDA([seedBytes(Seeds.REFERRAL), bytes]);
+};
+
+export const findUserIndexPDA = (userId) =>
+  findPDA([seedBytes(Seeds.USER_INDEX), u64LE(userId)]);
+
+export const findUidMapPDA = (username) =>
+  findPDA([seedBytes(Seeds.UID_MAP), new TextEncoder().encode(username)]);
+
+export const findAdminPDA = (adminPubkey) =>
+  findPDA([seedBytes(Seeds.ADMIN), adminPubkey instanceof PublicKey ? adminPubkey.toBytes() : adminPubkey]);
+
+// Treasury-wallet role PDA — existence at [b"treasury_wallet", pubkey]
+// authorizes that address to withdraw the treasury (to itself).
+export const findTreasuryWalletPDA = (walletPubkey) =>
+  findPDA([seedBytes(Seeds.TREASURY_WALLET), walletPubkey instanceof PublicKey ? walletPubkey.toBytes() : walletPubkey]);
+
+export const findBlocklistPDA = (username) =>
+  findPDA([seedBytes(Seeds.BLOCKED), new TextEncoder().encode(username)]);
+
+// Companion visibility PDA — [b"moderation", username]. Absence = visible.
+export const findModerationPDA = (username) =>
+  findPDA([seedBytes(Seeds.MODERATION), new TextEncoder().encode(username)]);
+
+export const findShopItemPDA = (itemId) =>
+  findPDA([seedBytes(Seeds.SHOP_ITEM), u32LE(itemId)]);
+
+// Inventory lives at [b"inventory", username] — items travel with the
+// username (cosmetics survive key rotation / sale).
+export const findInventoryPDA = (username) =>
+  findPDA([seedBytes(Seeds.INVENTORY), new TextEncoder().encode(username)]);
+
+// ProfilePhoto lives at [b"profile_photo", username] — photo travels
+// with the username.
+export const findProfilePhotoPDA = (username) =>
+  findPDA([seedBytes(Seeds.PROFILE_PHOTO), new TextEncoder().encode(username)]);
+

package/src/wallet.js

@@ -0,0 +1,189 @@
+// Wallet-adapter helper — sign + send a Transaction via a connected
+// browser wallet (Phantom, Solflare, Backpack, …).
+//
+// Ported from the legacy SDK (`tx.js#walletSignAndSend`) and adapted to
+// v1.0.0's Connection-based world. The legacy helper operated on raw
+// serialized tx bytes and broadcast through a module-level `sendTx`
+// (which used a custom proxied fetch); v1.0.0 instead takes a
+// `Connection` so we can use `connection.sendRawTransaction` /
+// `connection.confirmTransaction` directly, and `Connection` itself is
+// the integration point for proxied fetch + beforeRequest headers
+// (configured at construction time on PingDirectory).
+//
+// Tries three signing paths in order, mirroring the legacy SDK:
+//   1. Wallet Standard `solana:signTransaction`  — wallet returns
+//      signed bytes; we broadcast via `connection.sendRawTransaction`.
+//   2. Wallet Standard `solana:signAndSendTransaction` — wallet
+//      broadcasts itself and returns a signature.
+//   3. Legacy `provider.signTransaction(tx)` — the wallet object has
+//      a top-level `signTransaction` (older Phantom / wallet-adapter
+//      shims). We sign, then `sendRawTransaction`.
+//
+// Pure-JS, no extra deps. Uses only @solana/web3.js (already a SDK
+// dep) for the Transaction wire format.
+
+import { VersionedTransaction, Transaction } from '@solana/web3.js';
+
+// ── base58 encode (for signature bytes returned by Wallet Standard) ──
+// Tiny inline impl — avoids pulling in `bs58`. Identical alphabet to
+// the one Solana uses; signatures are always 64 bytes.
+const B58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+function b58encode(bytes) {
+  if (!bytes || bytes.length === 0) return '';
+  let zeros = 0;
+  while (zeros < bytes.length && bytes[zeros] === 0) zeros++;
+  const digits = [0];
+  for (let i = zeros; i < bytes.length; i++) {
+    let carry = bytes[i];
+    for (let j = 0; j < digits.length; j++) {
+      carry += digits[j] << 8;
+      digits[j] = carry % 58;
+      carry = (carry / 58) | 0;
+    }
+    while (carry > 0) {
+      digits.push(carry % 58);
+      carry = (carry / 58) | 0;
+    }
+  }
+  let out = '';
+  for (let i = 0; i < zeros; i++) out += '1';
+  for (let i = digits.length - 1; i >= 0; i--) out += B58_ALPHABET[digits[i]];
+  return out;
+}
+
+/**
+ * Serialize a Transaction or VersionedTransaction to wire bytes.
+ * Both classes expose `.serialize()`; legacy Transactions need
+ * `requireAllSignatures: false` because the wallet hasn't signed yet.
+ */
+function serializeTx(tx) {
+  if (tx instanceof VersionedTransaction) return tx.serialize();
+  if (tx instanceof Transaction) return tx.serialize({ requireAllSignatures: false, verifySignatures: false });
+  if (tx instanceof Uint8Array) return tx;
+  throw new Error('walletSignAndSend: transaction must be a Transaction, VersionedTransaction, or Uint8Array');
+}
+
+/**
+ * Best-effort detection of an account object suitable for Wallet
+ * Standard `solana:signTransaction` calls. Wallet Standard expects
+ * `{ address, publicKey, chains, features }`. If the wallet object
+ * already has an `account` field (the case when produced by our
+ * legacy-style `connectSolanaWallet`), use it directly. Otherwise we
+ * synthesize one from `pubkeyBytes`.
+ */
+function resolveAccount(wallet, chainId) {
+  if (wallet.account) return wallet.account;
+  if (wallet.pubkeyBytes) {
+    return {
+      address: b58encode(wallet.pubkeyBytes),
+      publicKey: wallet.pubkeyBytes,
+      chains: [chainId],
+      features: ['solana:signTransaction', 'solana:signAndSendTransaction'],
+    };
+  }
+  return null;
+}
+
+/**
+ * Sign and send a transaction via a connected wallet, then await
+ * `confirmed` commitment.
+ *
+ * @param {Connection} connection — the SDK Connection to broadcast on.
+ * @param {object}     wallet     — wallet adapter:
+ *   - Wallet Standard: `{ provider: { features }, account?, pubkeyBytes?, type? }`
+ *   - Legacy: `{ provider: { signTransaction(tx) }, pubkeyBytes? }`
+ * @param {Transaction|VersionedTransaction|Uint8Array} transaction
+ * @param {object}    [opts]
+ * @param {string}    [opts.chainId='solana:mainnet'] — Wallet Standard
+ *   chain identifier passed to `signTransaction` so wallets on a
+ *   mismatched cluster can refuse the prompt instead of silently
+ *   broadcasting on the wrong network.
+ * @param {string}    [opts.commitment='confirmed']
+ * @returns {Promise<string>} the transaction signature (base58).
+ */
+export async function walletSignAndSend(connection, wallet, transaction, opts = {}) {
+  if (!connection || typeof connection.sendRawTransaction !== 'function') {
+    throw new Error('walletSignAndSend: connection (with sendRawTransaction) is required');
+  }
+  if (!wallet) throw new Error('walletSignAndSend: wallet is required');
+
+  const chainId = opts.chainId || 'solana:mainnet';
+  const commitment = opts.commitment || 'confirmed';
+  const provider = wallet.provider || wallet; // some adapters ARE the provider
+  const account = resolveAccount(wallet, chainId);
+
+  // ── Path 1: Wallet Standard `solana:signTransaction` ────────────────
+  // Returns signed bytes; we broadcast.
+  const stFeat = provider?.features?.['solana:signTransaction'];
+  if (stFeat && account) {
+    const txBytes = serializeTx(transaction);
+    let signedBytes;
+    try {
+      const [output] = await stFeat.signTransaction({
+        account,
+        transaction: txBytes,
+        chain: chainId,
+      });
+      signedBytes = output.signedTransaction;
+    } catch (e) {
+      // Fall through to next path on signing error (mirrors the legacy SDK).
+      console.warn('[wallet] WS signTransaction failed:', e?.message ?? e);
+    }
+    if (signedBytes) {
+      const sig = await connection.sendRawTransaction(signedBytes, {
+        skipPreflight: false,
+        preflightCommitment: commitment,
+      });
+      await connection.confirmTransaction(sig, commitment);
+      return sig;
+    }
+  }
+
+  // ── Path 2: Wallet Standard `solana:signAndSendTransaction` ─────────
+  // Wallet broadcasts; returns a 64-byte signature.
+  const saFeat = provider?.features?.['solana:signAndSendTransaction'];
+  if (saFeat && account) {
+    const txBytes = serializeTx(transaction);
+    try {
+      const [output] = await saFeat.signAndSendTransaction({
+        account,
+        transaction: txBytes,
+        chain: chainId,
+      });
+      const sig = b58encode(output.signature);
+      await connection.confirmTransaction(sig, commitment);
+      return sig;
+    } catch (e) {
+      console.warn('[wallet] WS signAndSendTransaction failed:', e?.message ?? e);
+    }
+  }
+
+  // ── Path 3: Legacy `provider.signTransaction(tx)` ───────────────────
+  // Older Phantom / wallet-adapter shims — pass a real Transaction
+  // instance, get a signed one back, then broadcast its bytes.
+  if (typeof provider?.signTransaction === 'function') {
+    let signed;
+    try {
+      // If caller gave us raw bytes, deserialize so the legacy adapter
+      // sees a Transaction object. Try VersionedTransaction first
+      // (modern format), fall back to legacy Transaction.
+      let tx = transaction;
+      if (tx instanceof Uint8Array) {
+        try { tx = VersionedTransaction.deserialize(tx); }
+        catch { tx = Transaction.from(tx); }
+      }
+      signed = await provider.signTransaction(tx);
+    } catch (e) {
+      throw new Error('Wallet signing failed: ' + (e?.message ?? 'unknown'));
+    }
+    const signedBytes = signed instanceof Uint8Array ? signed : signed.serialize();
+    const sig = await connection.sendRawTransaction(signedBytes, {
+      skipPreflight: false,
+      preflightCommitment: commitment,
+    });
+    await connection.confirmTransaction(sig, commitment);
+    return sig;
+  }
+
+  throw new Error('walletSignAndSend: no compatible signing method found on wallet');
+}