@swarm-tips/client 0.2.11 → 0.2.12

package/SBOM.spdx.json

@@ -2,10 +2,10 @@
   "spdxVersion": "SPDX-2.3",
   "dataLicense": "CC0-1.0",
   "SPDXID": "SPDXRef-DOCUMENT",
-  "name": "@swarm-tips/client-0.2.11",
-  "documentNamespace": "https://swarm.tips/sbom/client/0.2.11",
+  "name": "@swarm-tips/client-0.2.12",
+  "documentNamespace": "https://swarm.tips/sbom/client/0.2.12",
   "creationInfo": {
-    "created": "2026-10-14T05:01:22.104Z",
+    "created": "2026-10-16T05:41:05.183Z",
     "creators": [
       "Tool: sdk/client/scripts/generate-sbom.mjs",
       "Organization: Swarm Tips"
@@ -15,8 +15,8 @@
     {
       "name": "@swarm-tips/client",
       "SPDXID": "SPDXRef-Package",
-      "versionInfo": "0.2.11",
-      "downloadLocation": "https://www.npmjs.com/package/@swarm-tips/client/v/0.2.11",
+      "versionInfo": "0.2.12",
+      "downloadLocation": "https://www.npmjs.com/package/@swarm-tips/client/v/0.2.12",
       "filesAnalyzed": false,
       "licenseConcluded": "MIT",
       "licenseDeclared": "MIT"

package/dist/coordination-game/solana.js

@@ -10,10 +10,18 @@ const SESSION_TTL_MS = 24 * 60 * 60 * 1000;
 const MEMO_PROGRAM_ID = new PublicKey("MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr");
 export const SESSION_FEE_HEADROOM_LAMPORTS = 10_000_000;
 export function sessionFundLamports(stakeLamports) {
-    return Number(stakeLamports) + SESSION_FEE_HEADROOM_LAMPORTS;
+    const total = stakeLamports + BigInt(SESSION_FEE_HEADROOM_LAMPORTS);
+    if (total > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new SwarmClientError({ code: "INVALID_ARGUMENT", operation: "solana.sessionFundLamports", message: "stakeLamports exceeds safe integer range" });
+    }
+    return Number(total);
 }
 export function sessionBalanceFloor(stakeLamports) {
-    return Number(stakeLamports) + SESSION_FEE_HEADROOM_LAMPORTS / 2;
+    const total = stakeLamports + BigInt(SESSION_FEE_HEADROOM_LAMPORTS / 2);
+    if (total > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new SwarmClientError({ code: "INVALID_ARGUMENT", operation: "solana.sessionBalanceFloor", message: "stakeLamports exceeds safe integer range" });
+    }
+    return Number(total);
 }
 function walletForSession(session) {
     return {
@@ -140,6 +148,13 @@ export class CoordinationGameSolanaClient {
         for (let index = 0; index < attempts; index += 1) {
             await sleep(options.intervalMs ?? 1_500);
             const status = await this.connection.getSignatureStatus(signature);
+            if (status.value?.err) {
+                throw new SwarmClientError({
+                    code: "TRANSACTION_FAILED",
+                    operation: "solana.waitForSignature",
+                    message: `transaction ${signature} failed on-chain: ${JSON.stringify(status.value.err)}`,
+                });
+            }
             const confirmation = status.value?.confirmationStatus;
             if (confirmation === "confirmed" || confirmation === "finalized")
                 return;
@@ -250,7 +265,14 @@ export class CoordinationGameSolanaClient {
             signed = await wallet.signTransaction(transaction);
         }
         const signature = await this.connection.sendRawTransaction(signed.serialize());
-        await this.connection.confirmTransaction(signature, this.commitment);
+        const confirmed = await this.connection.confirmTransaction(signature, this.commitment);
+        if (confirmed?.value?.err) {
+            throw new SwarmClientError({
+                code: "TRANSACTION_FAILED",
+                operation: "solana.signBroadcastAndConfirm",
+                message: `transaction ${signature} failed on-chain: ${JSON.stringify(confirmed.value.err)}`,
+            });
+        }
         return signature;
     }
     async commitGuess(commitment, game, session) {

package/dist/http.js

@@ -14,11 +14,13 @@ export class HttpClient {
                 operation: "http.constructor",
                 message: "A fetch implementation is required",
             });
-        this.fetchImpl = candidate.bind(globalThis);
+        this.fetchImpl = options.fetch
+            ? (input, init) => options.fetch(input, init)
+            : candidate.bind(globalThis);
         this.getToken = options.getToken;
     }
     withNetwork(path) {
-        if (!this.network || this.network === "mainnet")
+        if (!this.network || this.network === "mainnet" || /[?&]network=/.test(path))
             return path;
         const separator = path.includes("?") ? "&" : "?";
         return `${path}${separator}network=${encodeURIComponent(this.network)}`;

package/dist/shillbot/api.js

@@ -67,10 +67,21 @@ export function validatePreparedTransaction(encoded, expected) {
     const shillbotId = SHILLBOT_PROGRAM_ID.toBase58();
     const shillbotIxs = inspected.instructions.filter((instruction) => instruction.program_id === shillbotId);
     const lifecycle = shillbotIxs.filter((instruction) => matchesDiscriminator(instruction.data_base64, expected.action));
-    if (lifecycle.length !== 1 || shillbotIxs.length !== 1) {
+    const companions = shillbotIxs.filter((instruction) => instruction !== lifecycle[0]);
+    const payoutDisc = shillbotInstructionDiscriminator("set_payout_to");
+    const validCompanions = companions.length === 0 ||
+        (expected.action === "claim" &&
+            companions.length === 1 &&
+            Buffer.from(companions[0].data_base64, "base64").subarray(0, 8).equals(payoutDisc) &&
+            inspected.instructions.indexOf(companions[0]) > inspected.instructions.indexOf(lifecycle[0]) &&
+            companions[0].accounts.length === 2 &&
+            (!expected.taskPda || companions[0].accounts[0] === expected.taskPda) &&
+            companions[0].accounts[1] === expected.wallet);
+    if (lifecycle.length !== 1 || !validCompanions) {
         throw new SwarmClientError({ code: "TRANSACTION_MISMATCH", operation: "shillbot.validatePreparedTransaction", message: "Expected exactly one matching Shillbot lifecycle instruction" });
     }
-    if (expected.taskPda && !lifecycle[0].accounts.includes(expected.taskPda)) {
+    const taskAccountIndex = expected.action === "create" ? 1 : 0;
+    if (expected.taskPda && lifecycle[0].accounts[taskAccountIndex] !== expected.taskPda) {
         throw new SwarmClientError({ code: "TRANSACTION_MISMATCH", operation: "shillbot.validatePreparedTransaction", message: "Task PDA differs from expectation" });
     }
     const alwaysAllowed = new Set([

package/dist/shillbot/index.js

@@ -210,10 +210,25 @@ export function buildTransaction(request) {
         },
     };
 }
+const COMPUTE_BUDGET_PROGRAM_ID = "ComputeBudget111111111111111111111111111111";
+const SECP256K1_PROGRAM_ID = "KeccakSecp256k11111111111111111111111111111";
+const SWITCHBOARD_PROGRAM_IDS = {
+    mainnet: "SBondMDrcV3K4kxZR1HNVT7osZxAHVHgYXL5Ze1oMUv",
+    devnet: "Aio4gaXjXzJNVLtzwtNVmSqGKpANtXhybbkhtAC94ji2",
+};
 export function inspectTransaction(encoded) {
     const bytes = Buffer.from(encoded, "base64");
+    let tx;
     try {
-        const tx = VersionedTransaction.deserialize(bytes);
+        tx = VersionedTransaction.deserialize(bytes);
+    }
+    catch {
+        tx = undefined;
+    }
+    if (tx) {
+        if (tx.message.addressTableLookups.length > 0) {
+            throw new Error("address lookup tables are not allowed in Shillbot lifecycle transactions");
+        }
         const keys = tx.message.staticAccountKeys;
         return {
             version: tx.version === "legacy" ? "legacy" : "v0",
@@ -228,22 +243,20 @@ export function inspectTransaction(encoded) {
             })),
         };
     }
-    catch {
-        const tx = Transaction.from(bytes);
-        const message = tx.compileMessage();
-        return {
-            version: "legacy",
-            fee_payer: message.accountKeys[0].toBase58(),
-            signers: message.accountKeys
-                .slice(0, message.header.numRequiredSignatures)
-                .map((key) => key.toBase58()),
-            instructions: message.instructions.map((ix) => ({
-                program_id: message.accountKeys[ix.programIdIndex].toBase58(),
-                accounts: ix.accounts.map((index) => message.accountKeys[index].toBase58()),
-                data_base64: Buffer.from(bs58.decode(ix.data)).toString("base64"),
-            })),
-        };
-    }
+    const legacyTx = Transaction.from(bytes);
+    const message = legacyTx.compileMessage();
+    return {
+        version: "legacy",
+        fee_payer: message.accountKeys[0].toBase58(),
+        signers: message.accountKeys
+            .slice(0, message.header.numRequiredSignatures)
+            .map((key) => key.toBase58()),
+        instructions: message.instructions.map((ix) => ({
+            program_id: message.accountKeys[ix.programIdIndex].toBase58(),
+            accounts: ix.accounts.map((index) => message.accountKeys[index].toBase58()),
+            data_base64: Buffer.from(bs58.decode(ix.data)).toString("base64"),
+        })),
+    };
 }
 export function verifyIntent(encoded, intent) {
     const { digest: _digest, ...rest } = intent;
@@ -255,14 +268,27 @@ export function verifyIntent(encoded, intent) {
         throw new Error("fee payer differs from intent");
     if (!inspected.signers.includes(intent.wallet))
         throw new Error("wallet is not a required signer");
+    const shillbotProgramId = SHILLBOT_PROGRAM_ID.toBase58();
+    const allowedPrograms = new Set([
+        shillbotProgramId,
+        COMPUTE_BUDGET_PROGRAM_ID,
+        ...(intent.action === "verify"
+            ? [SWITCHBOARD_PROGRAM_IDS[intent.network], SECP256K1_PROGRAM_ID]
+            : []),
+    ]);
+    for (const ix of inspected.instructions) {
+        if (!allowedPrograms.has(ix.program_id)) {
+            throw new Error(`unexpected companion program ${ix.program_id}`);
+        }
+    }
     const expectedDiscriminator = shillbotInstructionDiscriminator(intent.action === "submit" ? "submit_work" : `${intent.action}_task`);
-    const lifecycle = inspected.instructions.filter((ix) => ix.program_id === SHILLBOT_PROGRAM_ID.toBase58() &&
+    const lifecycle = inspected.instructions.filter((ix) => ix.program_id === shillbotProgramId &&
         Buffer.from(ix.data_base64, "base64")
             .subarray(0, 8)
             .equals(expectedDiscriminator));
     if (lifecycle.length !== 1)
         throw new Error("expected exactly one Shillbot lifecycle instruction");
-    const shillbotInstructions = inspected.instructions.filter((ix) => ix.program_id === SHILLBOT_PROGRAM_ID.toBase58());
+    const shillbotInstructions = inspected.instructions.filter((ix) => ix.program_id === shillbotProgramId);
     const payoutDiscriminator = shillbotInstructionDiscriminator("set_payout_to");
     const companions = shillbotInstructions.filter((ix) => ix !== lifecycle[0]);
     const lifecycleIndex = inspected.instructions.indexOf(lifecycle[0]);
@@ -289,6 +315,27 @@ export function verifyIntent(encoded, intent) {
     if (lifecycle[0].accounts.join(",") !== intent.accounts.join(",")) {
         throw new Error("lifecycle accounts differ from intent");
     }
+    if (intent.action === "create" &&
+        intent.arguments.escrowLamports !== undefined) {
+        const data = Buffer.from(lifecycle[0].data_base64, "base64");
+        if (data.length < 24)
+            throw new Error("create instruction data is truncated");
+        const view = new DataView(data.buffer, data.byteOffset + 16, 8);
+        if (view.getBigUint64(0, true) !== BigInt(String(intent.arguments.escrowLamports))) {
+            throw new Error("escrow amount differs from intent");
+        }
+    }
+    if (intent.action === "submit" &&
+        typeof intent.arguments.contentId === "string") {
+        const data = Buffer.from(lifecycle[0].data_base64, "base64");
+        if (data.length < 12)
+            throw new Error("submit instruction data is truncated");
+        const len = data.readUInt32LE(8);
+        if (data.length !== 12 + len ||
+            data.subarray(12, 12 + len).toString("utf8") !== intent.arguments.contentId) {
+            throw new Error("content id differs from intent");
+        }
+    }
     return inspected;
 }
 export async function signAndBroadcast(connection, encodedUnsigned, sign, confirmation) {
@@ -308,11 +355,11 @@ export async function signAndBroadcast(connection, encodedUnsigned, sign, confir
             verifySignatures: true,
         });
     const signature = await connection.sendRawTransaction(wire);
-    if (confirmation) {
-        await connection.confirmTransaction({ signature, ...confirmation }, "confirmed");
-    }
-    else {
-        await connection.confirmTransaction(signature, "confirmed");
+    const confirmed = confirmation
+        ? await connection.confirmTransaction({ signature, ...confirmation }, "confirmed")
+        : await connection.confirmTransaction(signature, "confirmed");
+    if (confirmed?.value?.err) {
+        throw new Error(`transaction ${signature} failed on-chain: ${JSON.stringify(confirmed.value.err)}`);
     }
     return signature;
 }

package/dist/vow/decoders/shillbot.d.ts

@@ -55,5 +55,6 @@ export declare const resolveShillbotState: StateResolver;
  *  §6 capture window: only Verified is attestable. Finalize closes the on-chain
  *  account, so post-finalize the attestation is permanently unverifiable. */
 export declare const shillbotValidStates: (accountKind: string) => readonly string[];
+export declare const SHILLBOT_VOW_PROGRAM_ID = "2tR37nqMpwdV4DVUHjzUmL1rH2DtkA8zrRA4EAhT7KMi";
 /** Convenience bundle for callers that just want the canonical Shillbot triple. */
 export declare const shillbotProtocol: ProtocolHandler;

package/dist/vow/decoders/shillbot.js

@@ -56,10 +56,7 @@ export const decodeShillbotTask = (data, accountKind) => {
     const client = new PublicKey(data.slice(8, 40)).toBase58();
     const agent = new PublicKey(data.slice(40, 72)).toBase58();
     const state = data[72];
-    // platform is at offset 73 but unused by the verifier (the wire
-    // format carries it directly; verifier's field-equality check
-    // covers it via the v1 §4 step 5 platform comparison done by the
-    // caller, not here).
+    const platform = data[73];
     const content_hash = bytesToHex(data.slice(82, 114));
     const content_id_hash = bytesToHex(data.slice(114, 146));
     const composite_score = view.getBigUint64(162, true);
@@ -70,6 +67,7 @@ export const decodeShillbotTask = (data, accountKind) => {
         client,
         agent,
         state,
+        platform,
         composite_score,
         verified_at,
         verification_hash,
@@ -115,11 +113,13 @@ export const shillbotValidStates = (accountKind) => {
         return [];
     return ["verified"];
 };
+export const SHILLBOT_VOW_PROGRAM_ID = "2tR37nqMpwdV4DVUHjzUmL1rH2DtkA8zrRA4EAhT7KMi";
 /** Convenience bundle for callers that just want the canonical Shillbot triple. */
 export const shillbotProtocol = {
     decode: decodeShillbotTask,
     resolveState: resolveShillbotState,
     validStates: shillbotValidStates,
+    programId: SHILLBOT_VOW_PROGRAM_ID,
 };
 function bytesToHex(b) {
     let s = "";

package/dist/vow/schema.js

@@ -116,9 +116,12 @@ function isRfc3339NoFraction(v) {
     if (!pattern.test(v))
         return false;
     // Round-trip via Date to confirm the components describe a real
-    // moment (rejects e.g. "2026-13-32T25:61:99Z").
+    // moment (rejects e.g. "2026-13-32T25:61:99Z" and rollover dates like "2026-02-31T00:00:00Z").
     const ms = Date.parse(v);
-    return !Number.isNaN(ms);
+    if (Number.isNaN(ms))
+        return false;
+    const canonicalZ = v.replace(/\+00:00$/, "Z");
+    return new Date(ms).toISOString().replace(/\.\d+Z$/, "Z") === canonicalZ;
 }
 function isPlainObject(v) {
     return typeof v === "object" && v !== null && !Array.isArray(v);

package/dist/vow/types.d.ts

@@ -67,6 +67,7 @@ export interface DecodedAccount {
     verification_hash: string;
     content_hash: string;
     content_id_hash: string;
+    platform?: number;
 }
 /**
  * Per-protocol pluggable decoder. The verifier calls this with the
@@ -104,4 +105,5 @@ export interface ProtocolHandler {
     decode: AccountDecoder;
     resolveState: StateResolver;
     validStates: ValidStates;
+    programId?: string;
 }

package/dist/vow/verify.js

@@ -72,6 +72,9 @@ export async function verifyV1OnChain(a, protocol, rpc) {
     if (accountInfo.owner.toBase58() !== a.program_id) {
         return "owner_mismatch";
     }
+    if (protocol.programId !== undefined && accountInfo.owner.toBase58() !== protocol.programId) {
+        return "owner_mismatch";
+    }
     // Step 4 — Anchor discriminator check.
     if (data.length < 8) {
         return "discriminator_mismatch";
@@ -103,6 +106,9 @@ export async function verifyV1OnChain(a, protocol, rpc) {
     if (decoded.agent !== a.agent) {
         return "field_mismatch:agent";
     }
+    if (decoded.platform !== undefined && decoded.platform !== a.platform) {
+        return "field_mismatch:platform";
+    }
     if (decoded.composite_score.toString() !== a.composite_score) {
         return "field_mismatch:composite_score";
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarm-tips/client",
-  "version": "0.2.11",
+  "version": "0.2.12",
   "description": "Typed browser and Node.js clients for Swarm Tips, Shillbot, and Coordination Game",
   "type": "module",
   "main": "dist/index.js",