@goplausible/openclaw-algorand-plugin 1.9.4 → 2.0.0

package/lib/mcporter.ts

@@ -0,0 +1,75 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+
+import { ALGORAND_MCP } from "./mcp-servers.js";
+
+export function getMcpBinaryPath(pluginRoot: string): string {
+  const pluginBin = join(pluginRoot, "node_modules", ".bin", "algorand-mcp");
+  return existsSync(pluginBin) ? pluginBin : "algorand-mcp";
+}
+
+export function isMcpBinaryBundled(pluginRoot: string): boolean {
+  return existsSync(join(pluginRoot, "node_modules", ".bin", "algorand-mcp"));
+}
+
+export function mcporterConfigPath(): string {
+  return join(homedir(), ".mcporter", "mcporter.json");
+}
+
+type McporterServerEntry = {
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+  description?: string;
+};
+
+type McporterConfig = {
+  mcpServers: Record<string, McporterServerEntry>;
+  imports: string[];
+};
+
+export function isMcporterConfigured(): boolean {
+  const cfgPath = mcporterConfigPath();
+  if (!existsSync(cfgPath)) return false;
+  try {
+    const cfg = JSON.parse(readFileSync(cfgPath, "utf-8"));
+    return Boolean(cfg.mcpServers?.[ALGORAND_MCP.id]);
+  } catch {
+    return false;
+  }
+}
+
+export function upsertMcporterConfig(pluginRoot: string): { success: boolean; message: string } {
+  const cfgPath = mcporterConfigPath();
+  const cfgDir = dirname(cfgPath);
+
+  if (!existsSync(cfgDir)) mkdirSync(cfgDir, { recursive: true });
+
+  let cfg: McporterConfig = { mcpServers: {}, imports: [] };
+  if (existsSync(cfgPath)) {
+    try {
+      const parsed = JSON.parse(readFileSync(cfgPath, "utf-8"));
+      cfg = {
+        mcpServers: parsed.mcpServers ?? {},
+        imports: Array.isArray(parsed.imports) ? parsed.imports : [],
+      };
+    } catch (err) {
+      return { success: false, message: `Failed to parse ${cfgPath}: ${err}` };
+    }
+  }
+
+  const entry: McporterServerEntry = {
+    command: getMcpBinaryPath(pluginRoot),
+    description: "Algorand blockchain MCP (GoPlausible)",
+  };
+
+  const existing = cfg.mcpServers[ALGORAND_MCP.id];
+  if (existing?.command === entry.command && existing?.description === entry.description) {
+    return { success: true, message: `algorand-mcp already registered in ${cfgPath}` };
+  }
+
+  cfg.mcpServers[ALGORAND_MCP.id] = entry;
+  writeFileSync(cfgPath, JSON.stringify(cfg, null, 2));
+  return { success: true, message: `algorand-mcp registered in ${cfgPath}` };
+}

package/lib/workspace.ts

@@ -0,0 +1,216 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+
+import { upsertMcporterConfig } from "./mcporter.js";
+
+const PLUGIN_ID = "openclaw-algorand-plugin";
+
+export type WorkspaceApi = {
+  logger: { info: (m: string) => void; warn: (m: string) => void; error: (m: string) => void };
+  runtime?: {
+    agent?: {
+      resolveAgentWorkspaceDir?: () => string;
+      ensureAgentWorkspace?: () => Promise<string> | string;
+    };
+  };
+  config: Record<string, unknown>;
+};
+
+export function resolveWorkspaceDir(api: WorkspaceApi): string {
+  const rt = api.runtime?.agent;
+  if (rt?.resolveAgentWorkspaceDir) {
+    try { return rt.resolveAgentWorkspaceDir(); } catch { /* fall through */ }
+  }
+  const cfg = api.config as { agents?: { defaults?: { workspace?: string } } };
+  return cfg.agents?.defaults?.workspace ?? join(homedir(), ".openclaw", "workspace");
+}
+
+export function writeMemoryFile(pluginRoot: string, workspacePath: string): { success: boolean; message: string } {
+  const sourceFile = join(pluginRoot, "memory", "algorand-plugin.md");
+  const memoryDir = join(workspacePath, "memory");
+  const targetFile = join(memoryDir, "algorand-plugin.md");
+
+  if (!existsSync(sourceFile)) {
+    return { success: false, message: `Source memory/algorand-plugin.md not found at ${sourceFile}` };
+  }
+
+  if (!existsSync(memoryDir)) mkdirSync(memoryDir, { recursive: true });
+
+  writeFileSync(targetFile, readFileSync(sourceFile, "utf-8"));
+  return { success: true, message: `Plugin memory written to ${targetFile}` };
+}
+
+export function ensureWorkspaceMemoryIndex(pluginRoot: string, workspacePath: string): { success: boolean; message: string } {
+  const templateFile = join(pluginRoot, "memory", "MEMORY.md");
+
+  if (!existsSync(templateFile)) {
+    return { success: false, message: "Template MEMORY.md not found in plugin" };
+  }
+
+  const templateContent = readFileSync(templateFile, "utf-8");
+
+  const neverForgetMatch = templateContent.match(/## NEVER FORGET\n([\s\S]*?)(?=\n## (?!NEVER)|$)/);
+  if (!neverForgetMatch) {
+    return { success: false, message: "No NEVER FORGET section found in template MEMORY.md" };
+  }
+  const templateNeverForget = neverForgetMatch[1].trimEnd();
+
+  const memoryMdPath = join(workspacePath, "MEMORY.md");
+  const memoryMdLower = join(workspacePath, "memory.md");
+
+  const existingPath = existsSync(memoryMdPath) ? memoryMdPath
+    : existsSync(memoryMdLower) ? memoryMdLower
+    : null;
+
+  if (!existingPath) {
+    if (!existsSync(workspacePath)) mkdirSync(workspacePath, { recursive: true });
+    writeFileSync(memoryMdPath, templateContent);
+    return { success: true, message: `Created ${memoryMdPath} with NEVER FORGET section` };
+  }
+
+  let existing = readFileSync(existingPath, "utf-8");
+
+  if (!/## NEVER FORGET/i.test(existing)) {
+    const firstHeadingEnd = existing.match(/^# .+\n/m);
+    if (firstHeadingEnd) {
+      const insertPos = (firstHeadingEnd.index ?? 0) + firstHeadingEnd[0].length;
+      existing = existing.slice(0, insertPos) + "\n## NEVER FORGET\n" + templateNeverForget + "\n\n" + existing.slice(insertPos);
+    } else {
+      existing = "# OpenClaw Agent Long-Term Memory\n\n## NEVER FORGET\n" + templateNeverForget + "\n\n" + existing;
+    }
+    writeFileSync(existingPath, existing);
+    return { success: true, message: `Added NEVER FORGET section to ${existingPath}` };
+  }
+
+  const parseSubsections = (text: string): { header: string; content: string }[] => {
+    const sections: { header: string; content: string }[] = [];
+    const lines = text.split("\n");
+    let currentHeader = "";
+    let currentLines: string[] = [];
+    for (const line of lines) {
+      if (line.startsWith("### ")) {
+        if (currentHeader) sections.push({ header: currentHeader, content: currentLines.join("\n").trimEnd() });
+        currentHeader = line;
+        currentLines = [];
+      } else if (currentHeader) {
+        currentLines.push(line);
+      }
+    }
+    if (currentHeader) sections.push({ header: currentHeader, content: currentLines.join("\n").trimEnd() });
+    return sections;
+  };
+
+  const templateSections = parseSubsections(templateNeverForget);
+  const nfSectionMatch = existing.match(/(## NEVER FORGET\n)([\s\S]*?)(?=\n## (?!#)|$)/);
+  if (!nfSectionMatch) {
+    return { success: true, message: `NEVER FORGET section in ${existingPath} is up to date` };
+  }
+
+  let nfContent = nfSectionMatch[2];
+  let updated = false;
+
+  for (const templateSec of templateSections) {
+    if (templateSec.header === "### Never Do This") {
+      const neverDoRegex = /(### Never Do This\n)([\s\S]*?)(?=\n### |$)/;
+      const existingNeverDoMatch = nfContent.match(neverDoRegex);
+
+      if (!existingNeverDoMatch) {
+        nfContent = nfContent.trimEnd() + "\n\n" + templateSec.header + "\n" + templateSec.content + "\n";
+        updated = true;
+      } else {
+        let existingBullets = existingNeverDoMatch[2];
+        const templateBullets = templateSec.content.split("\n").filter((l: string) => l.startsWith("* "));
+        const existingBulletLines = existingBullets.split("\n").filter((l: string) => l.startsWith("* "));
+
+        for (const bullet of templateBullets) {
+          const fingerprint = bullet.slice(2, 52).trim();
+          const existingMatch = existingBulletLines.find((l: string) => l.includes(fingerprint));
+          if (existingMatch) {
+            if (existingMatch !== bullet) {
+              nfContent = nfContent.replace(existingMatch, bullet);
+              updated = true;
+            }
+          } else {
+            existingBullets = existingBullets.trimEnd() + "\n" + bullet;
+            nfContent = nfContent.replace(existingNeverDoMatch[2], existingBullets);
+            updated = true;
+          }
+        }
+      }
+    } else {
+      const escapedHeader = templateSec.header.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const sectionRegex = new RegExp("(" + escapedHeader + "\\n)([\\s\\S]*?)(?=\\n### |$)");
+      const existingSecMatch = nfContent.match(sectionRegex);
+
+      if (existingSecMatch) {
+        if (existingSecMatch[2].trimEnd() !== templateSec.content) {
+          nfContent = nfContent.replace(existingSecMatch[0], templateSec.header + "\n" + templateSec.content);
+          updated = true;
+        }
+      } else {
+        const neverDoPos = nfContent.indexOf("### Never Do This");
+        if (neverDoPos !== -1) {
+          nfContent = nfContent.slice(0, neverDoPos) + templateSec.header + "\n" + templateSec.content + "\n\n" + nfContent.slice(neverDoPos);
+        } else {
+          nfContent = nfContent.trimEnd() + "\n\n" + templateSec.header + "\n" + templateSec.content + "\n";
+        }
+        updated = true;
+      }
+    }
+  }
+
+  if (!updated) return { success: true, message: `NEVER FORGET section in ${existingPath} is up to date` };
+
+  existing = existing.replace(nfSectionMatch[2], nfContent);
+  writeFileSync(existingPath, existing);
+  return { success: true, message: `Updated NEVER FORGET subsections in ${existingPath}` };
+}
+
+export function runFirstLoadInit(api: WorkspaceApi, pluginRoot: string, workspacePath: string): void {
+  const markerPath = join(workspacePath, ".openclaw", `${PLUGIN_ID}.initialized`);
+  if (existsSync(markerPath)) return;
+
+  const markerDir = dirname(markerPath);
+  if (!existsSync(markerDir)) mkdirSync(markerDir, { recursive: true });
+
+  const mem = writeMemoryFile(pluginRoot, workspacePath);
+  if (mem.success) api.logger.info(`[algorand-plugin] ${mem.message}`);
+  else api.logger.warn(`[algorand-plugin] ${mem.message}`);
+
+  const memIdx = ensureWorkspaceMemoryIndex(pluginRoot, workspacePath);
+  if (memIdx.success) api.logger.info(`[algorand-plugin] ${memIdx.message}`);
+  else api.logger.warn(`[algorand-plugin] ${memIdx.message}`);
+
+  const mcp = upsertMcporterConfig(pluginRoot);
+  if (mcp.success) api.logger.info(`[algorand-plugin] ${mcp.message}`);
+  else api.logger.warn(`[algorand-plugin] ${mcp.message}`);
+
+  writeFileSync(markerPath, new Date().toISOString());
+}
+
+export function writePluginConfig(pluginConfig: Record<string, unknown>): { success: boolean; error?: string } {
+  try {
+    const configPath = join(homedir(), ".openclaw", "openclaw.json");
+    const configDir = dirname(configPath);
+    if (!existsSync(configDir)) mkdirSync(configDir, { recursive: true });
+
+    let config: Record<string, any> = {};
+    if (existsSync(configPath)) {
+      config = JSON.parse(readFileSync(configPath, "utf-8"));
+    }
+
+    config.plugins ??= {};
+    config.plugins.entries ??= {};
+    config.plugins.entries[PLUGIN_ID] ??= {};
+    config.plugins.entries[PLUGIN_ID].config = pluginConfig;
+
+    config.plugins.allow ??= [];
+    if (!config.plugins.allow.includes(PLUGIN_ID)) config.plugins.allow.push(PLUGIN_ID);
+
+    writeFileSync(configPath, JSON.stringify(config, null, 2));
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: String(err) };
+  }
+}

package/memory/MEMORY.md

@@ -26,6 +26,12 @@
 * `generate_algorand_qrcode` returns `qr` (UTF-8 text QR), `uri` (algorand:// URI), `link` (shareable hosted QR URL via QRClaw), and `expires_in` (link validity).
 * **Channel-aware output**: In TUI/Web channels, include UTF-8 QR block + URI + shareable link. In social channels (Telegram, Discord, WhatsApp, Slack, etc.), skip the QR block (too bulky) and show only URI + shareable link.
 
+### Transaction ID Delivery
+* ALWAYS present transaction IDs to the user after any successful transaction submission.
+* **Mainnet** explorer link: `https://allo.info/tx/{txId}`
+* **Testnet** explorer link: `https://lora.algokit.io/testnet/transaction/{txId}`
+* This applies to ALL transaction types: payments, transfers, opt-ins, app calls, atomic groups, Haystack swaps, Alpha Arcade trades, and x402 payments.
+
 ### Documentation
 * Use `get_knowledge_doc` MCP tool for Algorand developer documentation (categories: arcs, sdks, algokit, algokit-utils, tealscript, puya, liquid-auth, python, developers, clis, nodes, details).
 

package/memory/algorand-plugin.md

@@ -84,6 +84,17 @@ Shareable QR: [link URL]
   - **URI string** — for wallet deep links
   - **Shareable link** — renders nicely in-app as a clickable QR image
 
+## Post-Transaction: Deliver Transaction ID
+
+**ALWAYS** present the transaction ID to the user after any successful transaction. Use the correct explorer link:
+
+| Network | Explorer Link Template |
+|---------|----------------------|
+| `mainnet` | `https://allo.info/tx/{txId}` |
+| `testnet` | `https://lora.algokit.io/testnet/transaction/{txId}` |
+
+This applies to ALL operations that yield a transaction ID: payments, asset transfers, opt-ins, app calls, atomic groups, Haystack Router swaps, Alpha Arcade trades, and x402 payments.
+
 ## Key things to remember
 
 - Always check wallet with `wallet_get_info` before blockchain operations

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "openclaw-algorand-plugin",
   "name": "Algorand Integration",
   "description": "Algorand blockchain integration with MCP and skills — by GoPlausible",
-  "version": "1.9.4",
+  "version": "2.0.0",
   "skills": [
     "skills/algorand-development",
     "skills/algorand-typescript",
@@ -14,6 +14,15 @@
     "skills/haystack-router-interaction",
     "skills/alpha-arcade-interaction"
   ],
+  "activation": {
+    "commands": ["algorand-plugin"]
+  },
+  "commandAliases": [
+    {
+      "name": "algorand-plugin",
+      "description": "Algorand blockchain integration (GoPlausible)"
+    }
+  ],
   "configSchema": {
     "type": "object",
     "additionalProperties": false,
@@ -21,7 +30,7 @@
       "enableX402": {
         "type": "boolean",
         "default": true,
-        "description": "Enable x402 micropayments skills"
+        "description": "Enable x402 micropayments skills and x402_fetch tool"
       }
     }
   },
@@ -29,5 +38,19 @@
     "enableX402": {
       "label": "Enable x402 Micropayments"
     }
+  },
+  "setup": {
+    "summary": "Configure Algorand blockchain integration",
+    "steps": [
+      {
+        "id": "x402",
+        "label": "x402 Micropayments",
+        "description": "Enable the x402 HTTP-native payment protocol support (x402_fetch tool + skills).",
+        "configKey": "enableX402"
+      }
+    ],
+    "postSetup": {
+      "message": "Restart the OpenClaw gateway to apply changes. algorand-mcp is auto-registered in ~/.mcporter/mcporter.json on first load."
+    }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goplausible/openclaw-algorand-plugin",
-  "version": "1.9.4",
+  "version": "2.0.0",
   "publishConfig": {
     "access": "public"
   },
@@ -27,16 +27,25 @@
     "index.ts",
     "setup.ts",
     "lib/",
-    "scripts/",
     "skills/",
     "memory/",
     "openclaw.plugin.json"
   ],
   "openclaw": {
-    "extensions": ["./index.ts"]
+    "extensions": ["./index.ts"],
+    "compat": {
+      "pluginApi": ">=2026.3.14",
+      "minGatewayVersion": "2026.3.14"
+    }
   },
   "dependencies": {
     "@clack/prompts": "^0.7.0",
     "@goplausible/algorand-mcp": "latest"
+  },
+  "peerDependencies": {
+    "openclaw": ">=2026.3.14"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0"
   }
 }

package/setup.ts

@@ -1,30 +1,15 @@
 import * as p from "@clack/prompts";
-import { execSync } from "node:child_process";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
 import { ALGORAND_MCP, GOPLAUSIBLE_SERVICES } from "./lib/mcp-servers.js";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
 export interface AlgorandPluginConfig {
   enableX402: boolean;
 }
 
 export async function runSetup(
-  existingConfig?: Partial<AlgorandPluginConfig>
+  existingConfig?: Partial<AlgorandPluginConfig>,
 ): Promise<AlgorandPluginConfig | null> {
   p.intro("🔷 Algorand Plugin Setup — powered by GoPlausible");
 
-  // Step 1: Keyring persistence check & setup
-  p.log.step("Checking keyring persistence for wallet storage...");
-  try {
-    const scriptPath = join(__dirname, "scripts", "setup-keyring.sh");
-    execSync(`bash "${scriptPath}" --setup`, { stdio: "inherit" });
-  } catch {
-    p.log.warn("Keyring setup script failed — you may need to configure manually.");
-  }
-
-  // Step 2: x402 integration
   const enableX402 = await p.confirm({
     message: "Enable x402 micropayments integration?",
     initialValue: existingConfig?.enableX402 ?? true,
@@ -35,23 +20,22 @@ export async function runSetup(
     return null;
   }
 
-  // Summary
   const config: AlgorandPluginConfig = {
     enableX402: enableX402 as boolean,
   };
 
   p.note(
     `x402 Micropayments: ${config.enableX402 ? "Enabled" : "Disabled"}\n\n` +
-      `MCP Server Setup:\n` +
-      `  The Algorand MCP server (${ALGORAND_MCP.command}) provides 107 blockchain tools.\n` +
-      `  x402 micropayment and AP2 mandate verifiable credentials flows are fully supported in Algorand MCP.\n` ,
+      `MCP Server:\n` +
+      `  ${ALGORAND_MCP.name} (${ALGORAND_MCP.command}) — 107 blockchain tools.\n` +
+      `  Registered in ~/.mcporter/mcporter.json on first load.\n` +
+      `  x402 micropayment and AP2 mandate flows are fully supported.\n`,
   );
 
   p.outro(
     `🔷 Algorand plugin configured!\n\n` +
-      `   Next steps:\n` +
-      `   3. Restart OpenClaw gateway\n\n` +
-      `   GoPlausible website: ${GOPLAUSIBLE_SERVICES.website}`
+      `   Next step: restart OpenClaw gateway.\n\n` +
+      `   Docs: ${GOPLAUSIBLE_SERVICES.website}`,
   );
 
   return config;

package/skills/algorand-interaction/SKILL.md

@@ -110,7 +110,26 @@ Always check asset's `decimals` field with `api_algod_get_asset_by_id` before co
 | 3 | `make_*_txn` | Build the transaction |
 | 4 | `wallet_sign_transaction` | Sign with active wallet account (enforces limits) |
 | 5 | `send_raw_transaction` | Submit signed transaction to network |
-| 6 | Query tools | Verify result on-chain |
+| 6 | **Present txID** | Show transaction ID with explorer link (see below) |
+
+### Post-Transaction: Deliver Transaction ID
+
+**ALWAYS** present the transaction ID to the user after any successful transaction submission. Use the correct explorer link based on the network:
+
+| Network | Explorer Link Template |
+|---------|----------------------|
+| `mainnet` | `https://allo.info/tx/{txId}` |
+| `testnet` | `https://lora.algokit.io/testnet/transaction/{txId}` |
+
+Example output after a testnet transaction:
+> Transaction confirmed! `TXID123...`
+> View on explorer: https://lora.algokit.io/testnet/transaction/TXID123...
+
+Example output after a mainnet transaction:
+> Transaction confirmed! `TXID456...`
+> View on explorer: https://allo.info/tx/TXID456...
+
+This applies to ALL transaction types: payments, asset transfers, opt-ins, app calls, atomic groups, and any other operation that yields a transaction ID.
 
 ### One-Step Asset Opt-In
 
@@ -128,6 +147,7 @@ When the user provides their own secret key (not using the wallet):
 | 1 | `make_*_txn` | Build the transaction |
 | 2 | `sign_transaction` | Sign with provided secret key hex |
 | 3 | `send_raw_transaction` | Submit signed transaction |
+| 4 | **Present txID** | Show transaction ID with explorer link |
 
 ## Atomic Group Transaction Workflow
 
@@ -139,6 +159,7 @@ For atomic (all-or-nothing) multi-transaction groups:
 | 2 | `assign_group_id` | Assign group ID to all transactions |
 | 3 | `wallet_sign_transaction_group` | Sign all transactions in group with wallet |
 | 4 | `send_raw_transaction` | Submit all signed transactions |
+| 5 | **Present txIDs** | Show all transaction IDs with explorer links |
 
 ## Tool Categories
 

package/skills/algorand-interaction/references/examples-algorand-mcp.md

@@ -79,10 +79,21 @@ send_raw_transaction {
 }
 ```
 
-### Step 5: Verify (optional)
+### Step 5: Present transaction ID to user
+
+**ALWAYS** show the transaction ID with the correct explorer link:
+
+- **Mainnet**: `https://allo.info/tx/{txId}`
+- **Testnet**: `https://lora.algokit.io/testnet/transaction/{txId}`
+
+Example (testnet):
+> Transaction confirmed! `[txID_from_step_4]`
+> View on explorer: https://lora.algokit.io/testnet/transaction/[txID_from_step_4]
+
+Optionally verify on-chain:
 ```
 api_indexer_lookup_transaction_by_id {
-  "txId": "[txID_from_step_3]",
+  "txId": "[txID_from_step_4]",
   "network": "testnet"
 }
 ```
@@ -100,7 +111,7 @@ wallet_optin_asset {
 }
 ```
 
-This creates, signs, and submits the opt-in transaction in a single call.
+This creates, signs, and submits the opt-in transaction in a single call. Present the returned txID with explorer link.
 
 ---
 
@@ -142,6 +153,12 @@ send_raw_transaction {
 }
 ```
 
+### Step 5: Present transaction ID to user
+
+Show the txID with explorer link:
+- **Testnet**: `https://lora.algokit.io/testnet/transaction/{txId}`
+- **Mainnet**: `https://allo.info/tx/{txId}`
+
 ---
 
 ## Asset Transfer Workflow (USDC Example)
@@ -204,6 +221,12 @@ send_raw_transaction {
 }
 ```
 
+### Step 8: Present transaction ID to user
+
+Show the txID with explorer link:
+- **Testnet**: `https://lora.algokit.io/testnet/transaction/{txId}`
+- **Mainnet**: `https://allo.info/tx/{txId}`
+
 ---
 
 ## Atomic Group Transaction Workflow
@@ -252,6 +275,12 @@ send_raw_transaction {
 
 > Atomic groups are all-or-nothing: either all transactions succeed or none do.
 
+### Step 5: Present transaction IDs to user
+
+Show all txIDs from the group with explorer links:
+- **Testnet**: `https://lora.algokit.io/testnet/transaction/{txId}`
+- **Mainnet**: `https://allo.info/tx/{txId}`
+
 ---
 
 ## Create an ASA (Algorand Standard Asset)
@@ -299,6 +328,12 @@ api_algod_get_pending_transaction {
 ```
 > The `asset-index` field in the response contains the new ASA ID.
 
+### Step 5: Present transaction ID to user
+
+Show the txID with explorer link:
+- **Testnet**: `https://lora.algokit.io/testnet/transaction/{txId}`
+- **Mainnet**: `https://allo.info/tx/{txId}`
+
 ---
 
 ## Deploy a Smart Contract
@@ -347,6 +382,12 @@ send_raw_transaction {
 }
 ```
 
+### Step 5: Present transaction ID to user
+
+Show the txID with explorer link:
+- **Testnet**: `https://lora.algokit.io/testnet/transaction/{txId}`
+- **Mainnet**: `https://allo.info/tx/{txId}`
+
 ---
 
 ## NFD Lookup
@@ -592,6 +633,12 @@ send_raw_transaction {
 }
 ```
 
+### Step 4: Present transaction ID to user
+
+Show the txID with explorer link:
+- **Testnet**: `https://lora.algokit.io/testnet/transaction/{txId}`
+- **Mainnet**: `https://allo.info/tx/{txId}`
+
 ---
 
 ## Top-Up QR Code (Insufficient Funds)

package/skills/alpha-arcade-interaction/SKILL.md

@@ -138,6 +138,7 @@ If a trade fails with an "overspend" error, the wallet lacks sufficient ALGO or
 2. `get_orderbook` — check available liquidity
 3. `create_market_order` (auto-matches) or `create_limit_order` (rests on book)
 4. Save the returned `escrowAppId` — you need it to cancel
+5. **Present txID** — show transaction ID with explorer link (see Post-Transaction below)
 
 ### Checking your portfolio
 1. `get_positions` — see all YES/NO token balances with market titles and asset IDs
@@ -151,15 +152,29 @@ If a trade fails with an "overspend" error, the wallet lacks sufficient ALGO or
 ### Cancelling an order
 1. `get_open_orders` — find the `escrowAppId` and `owner` address
 2. `cancel_order` with `marketAppId`, `escrowAppId`, and `orderOwner`
+3. **Present txID** — show transaction ID with explorer link
 
 ### Claiming from a resolved market
 1. `get_positions` — find markets with token balances; note the `yesAssetId` or `noAssetId`
 2. `claim` with `marketAppId` and the winning token's `assetId`
+3. **Present txID** — show transaction ID with explorer link
 
 ### Providing liquidity (split/merge)
 1. `split_shares` — convert USDC into equal YES + NO tokens
 2. Place limit orders on both sides of the book for market making
 3. `merge_shares` — convert matched YES + NO tokens back to USDC
+4. **Present txIDs** — show transaction IDs with explorer links for each operation
+
+## Post-Transaction: Deliver Transaction ID
+
+**ALWAYS** present the transaction ID to the user after any successful trading operation (orders, cancellations, amendments, claims, splits, merges). Use the correct explorer link based on the network:
+
+| Network | Explorer Link Template |
+|---------|----------------------|
+| `mainnet` | `https://allo.info/tx/{txId}` |
+| `testnet` | `https://lora.algokit.io/testnet/transaction/{txId}` |
+
+This applies to all Alpha Arcade trading tools: `create_market_order`, `create_limit_order`, `cancel_order`, `amend_order`, `propose_match`, `split_shares`, `merge_shares`, and `claim`.
 
 ## Common Pitfalls