@x1scroll/agent-sdk 1.2.1 → 1.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@x1scroll/agent-sdk",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "Agent identity and on-chain memory protocol for X1 blockchain",
   "license": "BSL-1.1",
   "main": "src/index.js",

package/src/index.js

@@ -326,25 +326,26 @@ class AgentClient {
    *   X1 RPC endpoint (default: https://rpc.x1.xyz).
    *   Use https://rpc.x1scroll.io for our dedicated node.
    */
-  constructor({ wallet = null, rpcUrl = DEFAULT_RPC_URL } = {}) {
-    // ── resolve wallet ──
-    if (wallet === null || wallet === undefined) {
+  constructor({ wallet = null, keypair = null, rpcUrl = DEFAULT_RPC_URL } = {}) {
+    // ── resolve wallet — accept both `wallet` and `keypair` param names ──
+    const resolvedWallet = wallet || keypair;
+    if (resolvedWallet === null || resolvedWallet === undefined) {
       this.keypair       = null;
       this.walletAddress = null;
-    } else if (wallet instanceof Keypair) {
-      this.keypair       = wallet;
-      this.walletAddress = wallet.publicKey.toBase58();
-    } else if (typeof wallet === 'string') {
-      const secretKey    = bs58decode(wallet);
+    } else if (resolvedWallet instanceof Keypair) {
+      this.keypair       = resolvedWallet;
+      this.walletAddress = resolvedWallet.publicKey.toBase58();
+    } else if (typeof resolvedWallet === 'string') {
+      const secretKey    = bs58decode(resolvedWallet);
       this.keypair       = Keypair.fromSecretKey(secretKey);
       this.walletAddress = this.keypair.publicKey.toBase58();
-    } else if (wallet && wallet.secretKey && wallet.publicKey) {
+    } else if (resolvedWallet && resolvedWallet.secretKey && resolvedWallet.publicKey) {
       // Keypair-like object
-      this.keypair       = wallet;
-      this.walletAddress = wallet.publicKey.toBase58();
+      this.keypair       = resolvedWallet;
+      this.walletAddress = resolvedWallet.publicKey.toBase58();
     } else {
       throw new AgentSDKError(
-        'wallet must be a Keypair, a base58 secret key string, or null',
+        'wallet (or keypair) must be a Keypair, a base58 secret key string, or null',
         'INVALID_WALLET'
       );
     }
@@ -992,8 +993,24 @@ class AgentClient {
    * @param {Buffer|null}   [parentHash]  32-byte parent decision hash; zeros for root
    * @returns {Promise<{ sig: string, decisionHash: string, pda: string }>}
    */
-  async decisionWrite(agentKeypair, branchLabel, cid, outcome, confidence, parentHash = null) {
+  async decisionWrite(agentKeypair, branchLabelOrMessage, cidOrOpts, outcome, confidence, parentHash = null) {
     assertIsSigner(agentKeypair, 'agentKeypair');
+
+    // ── Simple overload: decisionWrite(keypair, type, message) ──
+    // Allows: client.decisionWrite(kp, 'trade', 'bought XNT at 0.34')
+    // Internally maps to branchLabel=type, cid=sha256(message), outcome=1, confidence=9000
+    let branchLabel, cid;
+    if (typeof cidOrOpts === 'string' && cidOrOpts.length < 64 && !cidOrOpts.startsWith('Qm') && outcome === undefined) {
+      branchLabel = branchLabelOrMessage;
+      // Hash the message string into a pseudo-CID for on-chain storage
+      cid         = 'msg:' + crypto.createHash('sha256').update(cidOrOpts).digest('hex').slice(0, 44);
+      outcome     = 1;    // executed
+      confidence  = 9000; // 90%
+    } else {
+      branchLabel = branchLabelOrMessage;
+      cid         = cidOrOpts;
+    }
+
     validateString(branchLabel, 'branchLabel', 64);
     validateString(cid, 'cid', 64);
 
@@ -1001,10 +1018,17 @@ class AgentClient {
     await this._assertSufficientBalance(agentKeypair, 1_000_000, 'decision_write (0.001 XNT)');
 
     if (typeof outcome !== 'number' || ![0, 1, 2].includes(outcome)) {
-      throw new AgentSDKError('outcome must be 0 (pending), 1 (executed), or 2 (rejected)', 'INVALID_INPUT');
+      throw new AgentSDKError(
+        `outcome must be 0 (pending), 1 (executed), or 2 (rejected) — got: ${JSON.stringify(outcome)}. ` +
+        'Tip: use the simple form decisionWrite(keypair, type, message) to skip outcome/confidence.',
+        'INVALID_INPUT'
+      );
     }
     if (typeof confidence !== 'number' || confidence < 0 || confidence > 10000) {
-      throw new AgentSDKError('confidence must be 0-10000 basis points', 'INVALID_INPUT');
+      throw new AgentSDKError(
+        `confidence must be 0-10000 basis points — got: ${JSON.stringify(confidence)}`,
+        'INVALID_INPUT'
+      );
     }
 
     // Derive decision_hash: sha256(JSON.stringify({cid, branchLabel, timestamp}))
@@ -1179,8 +1203,17 @@ class AgentClient {
       throw new AgentSDKError('limit must be a positive integer', 'INVALID_INPUT');
     }
 
-    const agentPdaPubkey = new PublicKey(agentPda);
-    const connection     = this._getConnection();
+    let agentPdaPubkey;
+    try {
+      agentPdaPubkey = new PublicKey(agentPda);
+    } catch (err) {
+      throw new AgentSDKError(
+        `contextGet: invalid agentPda — expected a base58 public key, got: ${JSON.stringify(agentPda)}`,
+        'INVALID_INPUT', err
+      );
+    }
+
+    const connection = this._getConnection();
 
     // Fetch recent signatures for this address
     const sigs = await connection.getSignaturesForAddress(agentPdaPubkey, { limit });
@@ -1222,8 +1255,15 @@ class AgentClient {
           });
           break; // one entry per tx
         }
-      } catch (_) {
-        // skip transactions we can't parse
+      } catch (err) {
+        // Log parse failures but don't block — one bad tx shouldn't kill the whole query
+        entries.push({
+          slot:        sigInfo.slot,
+          sig:         sigInfo.signature,
+          instruction: 'ParseError',
+          error:       err.message || String(err),
+          blockTime:   sigInfo.blockTime || null,
+        });
       }
     }));