@xgamesfun/solana 0.20.1 → 0.24.0

package/js/chain/lookup.js

@@ -222,12 +222,14 @@ async function freshSlot(rpc, payer) {
  * first (`planTable`); else the table first, then each compressed NFT's prove_leaf alone, then the rest as v0 (or the
  * proofs then a legacy rest, when that fits with no table). The v0 transaction is compiled against the table as the
  * chain holds it. `sign(message)` → the signed wire transaction. `rpc`: the client's (latestBlockhash, send, confirm,
- * account, call('getSlot')). `table: false` sends no lookup table (a throwaway key holds no rent for one); `first`:
+ * account, call('getSlot')). `standing`: tables already made ([{ address, addresses }], a project's, active), tried
+ * first: one v0 transaction with them when they hold enough. `table: false` sends no lookup table of its own (a throwaway
+ * key holds no rent for one); `first`:
  * addresses a table holds first (`planTable`). Throws a
  * plain sentence when it can't be sent. Returns { signature (the last transaction's), table (its address, or null),
  * steps (the signatures of the transactions before it) }.
  */
-export async function sendFitting({ rpc, payer, instructions, sign, table = true, alone = () => false, first = [], sleep = pause }) {
+export async function sendFitting({ rpc, payer, instructions, sign, table = true, alone = () => false, first = [], standing = [], sleep = pause }) {
   const sendOne = async (build) => {
     const { blockhash, lastValidBlockHeight } = await rpc.latestBlockhash();
     const message = build(blockhash);
@@ -240,6 +242,10 @@ export async function sendFitting({ rpc, payer, instructions, sign, table = true
   const plan = sendPlan({ payer, blockhash, instructions, alone });
   if (!plan) throw new Error(`This transaction is too large to send even as a v0 one with a lookup table: it names ${tableAccounts(instructions).length + 1} accounts or more (a transaction locks at most 64), or its instructions are too long.`);
   if (plan.legacy) return { signature: await plain(instructions), table: null, steps: [] };
+  // Standing tables (a project's, made at go-live; each still active) that hold enough of its accounts: one v0
+  // transaction with them, and no table of its own.
+  const fits = standing.length && compileFitting({ payer, blockhash, instructions, tables: standing });
+  if (fits && fits[0] === 0x80) return { signature: await sendOne((bh) => compileMessage({ payer, blockhash: bh, instructions, version: 0, lookupTables: standing })), table: null, steps: [] };
   if (plan.table && !table) throw new Error(`This transaction takes ${sizeOf({ payer, blockhash, instructions })} bytes, more than the ${MAX_TRANSACTION_BYTES} a legacy one holds, and this key holds no rent for a lookup table.`);
   const steps = [];
   const proofs = async () => {

package/js/chain/rpc.js

@@ -59,13 +59,15 @@ export async function checkCluster(rpc) {
 const decodeAccount = (raw) =>
   raw ? { owner: raw.owner, lamports: raw.lamports, data: fromBase64(raw.data[0]), executable: raw.executable } : null;
 
-/** The program's own words for a failed run (`AnchorError … Error Message: …`), else the last error log line. */
+/** The program's own words for a failed run (`AnchorError … Error Message: …`), else the last error log line. A program
+ * built without its errors' text logs the error's name as its message: then the name alone (the client's IDL has
+ * the sentence: `loot.lootError`). */
 export function programError(err, logs) {
   const anchor = logs?.find((line) => line.includes('AnchorError'));
   const said = anchor ? /Error Message: (.+?)\.?$/.exec(anchor)?.[1] : undefined;
   const code = anchor ? /Error Code: (\w+)/.exec(anchor)?.[1] : undefined;
   const last = logs?.filter((l) => /error|failed|insufficient/i.test(l)).at(-1);
-  if (said) return code ? `${said} (${code})` : said;
+  if (said) return code && code !== said ? `${said} (${code})` : said;
   return last ?? (typeof err === 'string' ? err : JSON.stringify(err));
 }