@lawrenceliang-btc/atel-sdk 1.1.37 → 1.1.39

package/bin/atel.mjs

@@ -336,8 +336,10 @@ async function pushTradeNotification(eventType, payload, body) {
       return `❌ 里程碑 M${p.milestoneIndex ?? '?'} 被拒绝\n订单: ${p.orderId || body?.orderId || '?'}${desc}\n原因: ${p.rejectReason || '未说明'}`;
     },
     'order_settled': (p) => {
-      const amount = p.priceAmount ? `\n金额: $${p.priceAmount} USDC${chainLabel(p)}` : '';
-      return `💰 订单已结算完成\n订单: ${p.orderId || body?.orderId || '?'}${amount}\nUSDC 已支付`;
+      const cl = chainLabel(p);
+      const amount = p.priceAmount ? `\n金额: $${p.priceAmount} USDC${cl}` : '';
+      const dest = cl === ' (Fast)' ? '\n资金已到达执行方 Fast 钱包' : '\nUSDC 已支付';
+      return `💰 订单已结算完成\n订单: ${p.orderId || body?.orderId || '?'}${amount}${dest}`;
     },
   };
   const tmpl = templates[eventType];
@@ -3636,6 +3638,22 @@ Format:
       dedupeKey: body.dedupeKey,
     });
 
+    // ── Fast-coop: auto-submit deliverable when all milestones verified ──
+    // When executor receives the final milestone_verified for a fast-coop order,
+    // sign and submit Escrow::Submit on Fast staging so the Platform can Complete.
+    if (event === 'milestone_verified' && payload.allComplete === true) {
+      const orderChain = payload.chain || body.chain || '';
+      const isExecutor = payload.executorDid === id.did || (payload.orderDescription && payload.requesterDid !== id.did);
+      if (orderChain === 'fast-coop' && isExecutor) {
+        const fastOrderId = body.orderId || payload.orderId || '';
+        log({ event: 'fast_submit_triggered', orderId: fastOrderId, chain: orderChain });
+        // Fire-and-forget: submit deliverable hash to Fast escrow
+        submitFastDeliverable(fastOrderId, id).catch(e => {
+          log({ event: 'fast_submit_error', orderId: fastOrderId, error: e.message });
+        });
+      }
+    }
+
     const dedupeKey = body.dedupeKey || `${event}:${body.orderId || payload.orderId || ''}`;
     const orderIdForCwd = body.orderId || payload.orderId || '';
     let workspace = getOrderWorkspace(orderIdForCwd, {
@@ -8367,6 +8385,129 @@ async function cmdAliasRemove(args) {
 
 // ─── Main ────────────────────────────────────────────────────────
 
+// ── Fast-coop: Executor auto-submit deliverable to Fast escrow ──────
+// Called when executor receives milestone_verified with allComplete=true
+// for a fast-coop order. Signs Escrow::Submit with the agent's DID
+// private key (= Fast Ed25519 account key).
+async function submitFastDeliverable(orderId, identity) {
+  try {
+    // 1. Get order info to find the escrow job_id
+    const orderInfo = await fetchOrderState(orderId);
+    if (!orderInfo) throw new Error('cannot fetch order');
+    const chain = orderInfo.chain || orderInfo.Chain || '';
+    if (chain !== 'fast-coop') return;
+
+    // 2. Find escrow job_id from chain-records
+    const recordsResp = await fetch(`${PLATFORM_URL}/trade/v1/order/${orderId}`, {
+      signal: AbortSignal.timeout(10000),
+    });
+    // The job_id is stored in the on_chain_records by the Platform.
+    // We need to get it from the order or from the chain-records endpoint.
+    // For now, compute it the same way Platform does: keccak256(orderId)
+    const { createHash } = await import('node:crypto');
+
+    // 3. Get the agent's Fast account info
+    const FAST_RPC = process.env.ATEL_FASTCOOP_RPC_URL || 'https://staging.api.fast.xyz/proxy-rest';
+    const pubKeyHex = Buffer.from(identity.publicKey).toString('hex');
+
+    const accountResp = await fetch(`${FAST_RPC}/v1/accounts/${pubKeyHex}`, {
+      signal: AbortSignal.timeout(10000),
+    });
+    if (!accountResp.ok) throw new Error(`Fast account query failed: ${accountResp.status}`);
+    const accountData = (await accountResp.json()).data;
+    const nonce = accountData.next_nonce;
+
+    // 4. Find escrow job for this order (query by provider)
+    const jobsResp = await fetch(`${FAST_RPC}/v1/escrow-jobs?provider=${pubKeyHex}&status=Funded`, {
+      signal: AbortSignal.timeout(10000),
+    });
+    if (!jobsResp.ok) throw new Error(`escrow jobs query failed: ${jobsResp.status}`);
+    const jobs = (await jobsResp.json()).data || [];
+    const job = jobs.find(j => j.description && j.description.includes(orderId));
+    if (!job) {
+      log({ event: 'fast_submit_no_job', orderId, note: 'no Funded escrow job found for this order' });
+      return;
+    }
+
+    // 5. Build Escrow::Submit transaction
+    // deliverable = keccak256(orderId) as 32-byte hash
+    const deliverableHash = createHash('sha3-256').update(orderId).digest('hex');
+
+    // BCS encode: Operation::Escrow(12) → Escrow::Submit(2) → jobId(32) + deliverable(32)
+    const jobIdBytes = Buffer.from(job.job_id, 'hex');
+    const deliverableBytes = Buffer.from(deliverableHash, 'hex');
+
+    // Build minimal BCS by hand (matching Go implementation):
+    // ULEB128(12) = 0x0c, ULEB128(2) = 0x02, then 32+32 bytes
+    const claimBytes = Buffer.concat([
+      Buffer.from([0x0c]),        // Operation::Escrow variant 12
+      Buffer.from([0x02]),        // Escrow::Submit variant 2
+      jobIdBytes.subarray(0, 32), // job_id 32 bytes
+      deliverableBytes.subarray(0, 32), // deliverable 32 bytes
+    ]);
+
+    // Transaction BCS: VersionedTransaction variant 1 (Release20260407)
+    const networkId = process.env.ATEL_FASTCOOP_NETWORK_ID || 'fast:devnet';
+    const senderBytes = Buffer.from(identity.publicKey);
+    const tsNanos = BigInt(Date.now()) * 1000000n;
+
+    // ULEB128 encoder
+    const uleb128 = (v) => {
+      const buf = [];
+      do { let b = Number(v & 0x7fn); v >>= 7n; if (v > 0n) b |= 0x80; buf.push(b); } while (v > 0n);
+      return Buffer.from(buf.length ? buf : [0]);
+    };
+    const u64le = (v) => { const b = Buffer.alloc(8); b.writeBigUInt64LE(BigInt(v)); return b; };
+    const u128le = (v) => { const b = Buffer.alloc(16); b.writeBigUInt64LE(v & 0xffffffffffffffffn); b.writeBigUInt64LE(v >> 64n, 8); return b; };
+    const bcsString = (s) => { const b = Buffer.from(s, 'utf-8'); return Buffer.concat([uleb128(BigInt(b.length)), b]); };
+
+    // Transaction body
+    const txBody = Buffer.concat([
+      bcsString(networkId),
+      senderBytes.subarray(0, 32),
+      u64le(nonce),
+      u128le(tsNanos),
+      uleb128(1n), // claims vector length = 1
+      claimBytes,
+      Buffer.from([0x00]), // archival = false
+      Buffer.from([0x00]), // fee_token = None
+    ]);
+
+    // VersionedTransaction = enum variant 1
+    const versionedTx = Buffer.concat([uleb128(1n), txBody]);
+
+    // 6. Sign
+    const { default: nacl } = await import('tweetnacl');
+    const sigMessage = Buffer.concat([Buffer.from('VersionedTransaction::'), versionedTx]);
+    const signature = nacl.sign.detached(sigMessage, identity.secretKey);
+
+    // SignatureOrMultiSig::Signature = variant 0 + 64 bytes
+    const bcsSig = Buffer.concat([Buffer.from([0x00]), Buffer.from(signature)]);
+
+    // 7. Submit to Fast
+    const submitResp = await fetch(`${FAST_RPC}/v1/submit-transaction`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        transaction: versionedTx.toString('hex'),
+        signature: bcsSig.toString('hex'),
+      }),
+      signal: AbortSignal.timeout(15000),
+    });
+
+    const submitResult = await submitResp.json();
+    if (submitResult.error) {
+      throw new Error(`Fast submit failed: ${submitResult.error.message || JSON.stringify(submitResult.error)}`);
+    }
+
+    log({ event: 'fast_submit_success', orderId, jobId: job.job_id, nonce });
+    console.log(`⚡ [Fast] Deliverable submitted for ${orderId} (job: ${job.job_id.substring(0, 16)}...)`);
+  } catch (e) {
+    log({ event: 'fast_submit_error', orderId, error: e.message });
+    console.error(`⚠️  [Fast] Submit failed for ${orderId}: ${e.message}`);
+  }
+}
+
 const [,, cmd, ...rawArgs] = process.argv;
 const args = rawArgs.filter(a => !a.startsWith('--'));
 const commands = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lawrenceliang-btc/atel-sdk",
-  "version": "1.1.37",
+  "version": "1.1.39",
   "description": "ATEL Protocol SDK - Agent Trust & Exchange Layer",
   "repository": {
     "type": "git",