@agirails/sdk 2.3.0 → 2.3.1

package/src/cli/commands/init.ts

@@ -32,6 +32,7 @@ export function createInitCommand(): Command {
     .description('Initialize ACTP in the current directory')
     .option('-m, --mode <mode>', 'Operating mode: mock, testnet, mainnet', 'mock')
     .option('-a, --address <address>', 'Your Ethereum address')
+    .option('-w, --wallet <type>', 'Wallet type: auto (gas-free Smart Wallet) or eoa (traditional)', 'auto')
     .option('-f, --force', 'Overwrite existing configuration')
     .option('--scaffold', 'Generate a starter agent.ts file')
     .option('--intent <intent>', 'Agent intent: earn, pay, or both (default: earn)')
@@ -67,6 +68,7 @@ type ScaffoldIntent = 'earn' | 'pay' | 'both';
 interface InitOptions {
   mode: string;
   address?: string;
+  wallet?: string;
   force?: boolean;
   scaffold?: boolean;
   intent?: string;
@@ -95,8 +97,18 @@ async function runInit(options: InitOptions, output: Output): Promise<void> {
 
   const mode = options.mode as CLIMode;
 
+  // Determine wallet type
+  const walletType = (mode === 'mock') ? 'mock' : (options.wallet || 'auto');
+  if (walletType !== 'mock' && walletType !== 'auto' && walletType !== 'eoa') {
+    throw new Error(
+      `Invalid wallet type: "${walletType}". Valid types: auto, eoa`
+    );
+  }
+
   // Get or generate address
   let address = options.address;
+  let smartWalletAddress: string | undefined;
+  let didRegister = false;
   if (!address) {
     if (mode === 'mock') {
       // Generate a random address for mock mode
@@ -106,7 +118,24 @@ async function runInit(options: InitOptions, output: Output): Promise<void> {
       // Generate a real wallet with encrypted keystore
       const actpDir = getActpDir(projectRoot);
       fs.mkdirSync(actpDir, { recursive: true });
-      address = await generateWallet(actpDir, output);
+      const eoaAddress = await generateWallet(actpDir, output);
+
+      if (walletType === 'auto') {
+        // Compute Smart Wallet address from signer
+        smartWalletAddress = await computeSmartWalletInit(eoaAddress, mode, output);
+
+        // Y/N: Register for gas-free transactions?
+        const shouldRegister = await promptRegister(output);
+        if (shouldRegister) {
+          didRegister = await runInlineRegistration(projectRoot, mode, output);
+        }
+
+        // address = Smart Wallet if registered, EOA if not
+        // This ensures CLI commands (balance, tx list) show the correct address
+        address = didRegister ? smartWalletAddress : eoaAddress;
+      } else {
+        address = eoaAddress;
+      }
     }
   }
 
@@ -123,6 +152,9 @@ async function runInit(options: InitOptions, output: Output): Promise<void> {
     mode,
     address: address.toLowerCase(),
     version: '1.0',
+    ...(walletType !== 'mock' && { wallet: walletType as 'auto' | 'eoa' }),
+    ...(smartWalletAddress && { smartWallet: smartWalletAddress.toLowerCase() }),
+    ...(didRegister && { registered: true }),
   };
 
   // Save configuration
@@ -160,6 +192,7 @@ async function runInit(options: InitOptions, output: Output): Promise<void> {
       directory: getActpDir(projectRoot),
       mode,
       address,
+      ...(walletType !== 'mock' && { wallet: walletType }),
     },
     { quietKey: 'address' }
   );
@@ -170,9 +203,21 @@ async function runInit(options: InitOptions, output: Output): Promise<void> {
   } else {
     output.blank();
     output.print('Next steps:');
-    output.print('  1. Create a payment: actp pay <provider> <amount>');
-    output.print('  2. Check your balance: actp balance');
-    output.print('  3. List transactions: actp tx list');
+    if (walletType === 'auto' && didRegister) {
+      // Already registered — ready to go
+      output.print('  1. Create a payment: actp pay <provider> <amount>');
+      output.print('  2. Check your balance: actp balance');
+      output.print('  3. List transactions: actp tx list');
+    } else if (walletType === 'auto') {
+      // Skipped registration — remind them
+      output.print('  1. Register for gas-free: actp register');
+      output.print('  2. Create a payment: actp pay <provider> <amount>');
+      output.print('  3. Check your balance: actp balance');
+    } else {
+      output.print('  1. Create a payment: actp pay <provider> <amount>');
+      output.print('  2. Check your balance: actp balance');
+      output.print('  3. List transactions: actp tx list');
+    }
     output.print('');
     output.print('Tip: Use --scaffold to generate a starter agent.ts');
   }
@@ -219,6 +264,201 @@ async function generateWallet(actpDir: string, output: Output): Promise<string>
   return wallet.address;
 }
 
+/**
+ * Compute the Smart Wallet address for an EOA signer.
+ * Uses CREATE2 counterfactual derivation — no deployment needed.
+ */
+async function computeSmartWalletInit(
+  eoaAddress: string,
+  mode: string,
+  output: Output
+): Promise<string> {
+  const { ethers } = await import('ethers');
+  const { getNetwork } = await import('../../config/networks');
+  const { computeSmartWalletAddress } = await import('../../wallet/aa/UserOpBuilder');
+
+  const network = mode === 'testnet' ? 'base-sepolia' : 'base-mainnet';
+  const networkConfig = getNetwork(network);
+  const rpcUrl = networkConfig.rpcUrl;
+  const provider = new ethers.JsonRpcProvider(rpcUrl);
+
+  output.info('Computing Smart Wallet address...');
+  const smartWalletAddress = await computeSmartWalletAddress(eoaAddress, provider);
+
+  output.success(`Smart Wallet: ${smartWalletAddress}`);
+  output.info('Gas-free transactions enabled (requires registration)');
+  output.info('Register with: actp register');
+
+  return smartWalletAddress;
+}
+
+/**
+ * Ask user if they want to register for gas-free transactions.
+ * Non-TTY (piped/agent) defaults to yes.
+ */
+async function promptRegister(output: Output): Promise<boolean> {
+  output.blank();
+  output.print('Register for gas-free transactions? (recommended)');
+  output.print('  Your agent gets a Smart Wallet with sponsored gas — no ETH needed.');
+  output.print('  Requires on-chain registration on AgentRegistry.');
+  output.blank();
+
+  if (!process.stdin.isTTY) {
+    output.info('Non-interactive mode: auto-registering');
+    return true;
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question('  Register now? [Y/n] ', (answer) => {
+      rl.close();
+      const trimmed = answer.trim().toLowerCase();
+      resolve(trimmed === '' || trimmed === 'y' || trimmed === 'yes');
+    });
+  });
+}
+
+/**
+ * Run inline registration during init.
+ * Reuses the same logic as `actp register` — parses AGIRAILS.md,
+ * builds gasless UserOp (testnet: register + mint 1000 USDC).
+ *
+ * Returns true if registration succeeded, false on failure (non-fatal).
+ */
+async function runInlineRegistration(
+  projectRoot: string,
+  mode: string,
+  output: Output
+): Promise<boolean> {
+  try {
+    const { resolvePrivateKey } = await import('../../wallet/keystore');
+    const privateKey = await resolvePrivateKey(projectRoot);
+    if (!privateKey) {
+      output.warning('Could not load wallet key. Run "actp register" later.');
+      return false;
+    }
+
+    const { parseAgirailsMd } = await import('../../config/agirailsmd');
+    const { extractRegistrationParams } = await import('../../config/publishPipeline');
+    const { ethers } = await import('ethers');
+    const { getNetwork } = await import('../../config/networks');
+    const { AutoWalletProvider } = await import('../../wallet/AutoWalletProvider');
+    const { buildRegisterAgentBatch, buildTestnetInitBatch } = await import('../../wallet/aa/TransactionBatcher');
+
+    // Parse AGIRAILS.md if present
+    const agirailsMdPath = path.join(projectRoot, 'AGIRAILS.md');
+    let endpoint = '';
+    let serviceDescriptors;
+
+    if (fs.existsSync(agirailsMdPath)) {
+      const content = fs.readFileSync(agirailsMdPath, 'utf-8');
+      const parsed = parseAgirailsMd(content);
+      const regParams = extractRegistrationParams(parsed.frontmatter);
+      endpoint = regParams.endpoint;
+      serviceDescriptors = regParams.serviceDescriptors;
+      output.info(`Parsed ${serviceDescriptors.length} service(s) from AGIRAILS.md`);
+    } else {
+      const serviceType = 'general';
+      serviceDescriptors = [{
+        serviceTypeHash: ethers.keccak256(ethers.toUtf8Bytes(serviceType)),
+        serviceType,
+        schemaURI: '',
+        minPrice: 0n,
+        maxPrice: 1_000_000_000n,
+        avgCompletionTime: 3600,
+        metadataCID: '',
+      }];
+      output.info('No AGIRAILS.md found. Using default "general" service.');
+    }
+
+    const network = mode === 'testnet' ? 'base-sepolia' : 'base-mainnet';
+    const networkConfig = getNetwork(network);
+
+    if (!networkConfig.aa || !networkConfig.contracts.agentRegistry) {
+      output.warning('AA or AgentRegistry not configured. Run "actp register" later.');
+      return false;
+    }
+
+    // Check for valid bundler/paymaster URL (CDP_API_KEY must be set)
+    const cdpUrl = networkConfig.aa.bundlerUrls.coinbase;
+    const hasPimlico = !!networkConfig.aa.bundlerUrls.pimlico;
+    if (cdpUrl.endsWith('/') && !hasPimlico) {
+      output.warning('CDP_API_KEY not set. Skipping registration.');
+      output.info('Set CDP_API_KEY and run "actp register" later.');
+      return false;
+    }
+
+    const provider = new ethers.JsonRpcProvider(networkConfig.rpcUrl);
+    const signer = new ethers.Wallet(privateKey, provider);
+
+    const autoWallet = await AutoWalletProvider.create({
+      signer,
+      provider,
+      chainId: networkConfig.chainId,
+      actpKernelAddress: networkConfig.contracts.actpKernel,
+      bundler: {
+        primaryUrl: networkConfig.aa.bundlerUrls.coinbase,
+        backupUrl: networkConfig.aa.bundlerUrls.pimlico,
+      },
+      paymaster: {
+        primaryUrl: networkConfig.aa.paymasterUrls.coinbase,
+        backupUrl: networkConfig.aa.paymasterUrls.pimlico,
+      },
+    });
+
+    const smartWalletAddress = autoWallet.getAddress();
+
+    // Build batch
+    let calls;
+    if (mode === 'testnet') {
+      output.info('Testnet: registering + minting 1000 test USDC in one gasless tx...');
+      calls = buildTestnetInitBatch({
+        agentRegistryAddress: networkConfig.contracts.agentRegistry,
+        endpoint,
+        serviceDescriptors,
+        mockUsdcAddress: networkConfig.contracts.usdc,
+        recipient: smartWalletAddress,
+        mintAmount: '1000000000',
+      });
+    } else {
+      output.info('Registering on AgentRegistry (gasless)...');
+      calls = buildRegisterAgentBatch(
+        networkConfig.contracts.agentRegistry,
+        endpoint,
+        serviceDescriptors
+      );
+    }
+
+    const txRequests = calls.map((c) => ({
+      to: c.target,
+      data: c.data,
+      value: c.value.toString(),
+    }));
+
+    const receipt = await autoWallet.sendBatchTransaction(txRequests);
+
+    if (!receipt.success) {
+      output.warning(`Registration failed (tx: ${receipt.hash}). Run "actp register" later.`);
+      return false;
+    }
+
+    output.success('Agent registered on AgentRegistry');
+    if (mode === 'testnet') {
+      output.success('Minted 1,000 test USDC to Smart Wallet');
+    }
+    output.print(`  Tx: ${receipt.hash}`);
+    return true;
+  } catch (error) {
+    output.warning(`Registration failed: ${(error as Error).message}`);
+    output.info('You can register later with: actp register');
+    return false;
+  }
+}
+
 async function promptPassword(): Promise<string> {
   // If not a TTY (e.g. piped or run by agent), skip prompt
   if (!process.stdin.isTTY) {
@@ -297,8 +537,8 @@ async function runScaffold(
     const tsconfigContent = JSON.stringify({
       compilerOptions: {
         target: 'ES2022',
-        module: 'ES2022',
-        moduleResolution: 'bundler',
+        module: 'commonjs',
+        moduleResolution: 'node',
         esModuleInterop: true,
         strict: true,
         outDir: 'dist',
@@ -317,19 +557,7 @@ async function runScaffold(
     }
   }
 
-  // Check package.json for type: module
-  const pkgFile = path.join(process.cwd(), 'package.json');
-  if (fs.existsSync(pkgFile)) {
-    try {
-      const pkg = JSON.parse(fs.readFileSync(pkgFile, 'utf-8'));
-      if (pkg.type !== 'module') {
-        output.warning(
-          'package.json has type: "' + (pkg.type || 'commonjs') + '". ' +
-          'Set "type": "module" for ESM support, or run with: npx ts-node --esm agent.ts'
-        );
-      }
-    } catch { /* ignore parse errors */ }
-  }
+  // Note: @agirails/sdk is CJS — no type:module check needed
 
   output.blank();
   output.print('Next steps:');

package/src/cli/commands/publish.ts

@@ -13,8 +13,7 @@ import { mapError } from '../utils/client';
 import { resolve } from 'path';
 import { readFileSync, existsSync } from 'fs';
 import { ethers } from 'ethers';
-import { computeConfigHash, parseAgirailsMd, serializeAgirailsMd } from '../../config/agirailsmd';
-import { AgentRegistryClient } from '../../registry/AgentRegistryClient';
+import { computeConfigHash, parseAgirailsMd } from '../../config/agirailsmd';
 import { FilebaseClient } from '../../storage/FilebaseClient';
 import { ArweaveClient } from '../../storage/ArweaveClient';
 import { getNetwork } from '../../config/networks';

package/src/cli/commands/register.ts

@@ -0,0 +1,233 @@
+/**
+ * Register Command — Register agent on AgentRegistry for gas-free transactions.
+ *
+ * Parses AGIRAILS.md for service descriptors and endpoint, then registers
+ * on-chain via a single gasless UserOp (bootstrap-allowed).
+ *
+ * For testnet: also mints 1000 test USDC in the same UserOp.
+ *
+ * WARNING: This creates a NEW Smart Wallet address (different from EOA).
+ * Old EOA reputation/history does not transfer.
+ *
+ * @module cli/commands/register
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { Command } from 'commander';
+import { Output, ExitCode } from '../utils/output';
+import { loadConfig, updateConfig } from '../utils/config';
+import { resolvePrivateKey } from '../../wallet/keystore';
+
+// ============================================================================
+// Command Definition
+// ============================================================================
+
+export function createRegisterCommand(): Command {
+  const cmd = new Command('register')
+    .description('Register agent on AgentRegistry for gas-free transactions')
+    .option('--endpoint <url>', 'Service endpoint URL (overrides AGIRAILS.md)')
+    .option('--json', 'Output as JSON')
+    .option('-q, --quiet', 'Minimal output')
+    .action(async (options) => {
+      const output = new Output(
+        options.json ? 'json' : options.quiet ? 'quiet' : 'human'
+      );
+
+      try {
+        await runRegister(options, output);
+      } catch (error) {
+        output.errorResult({
+          code: 'REGISTER_FAILED',
+          message: (error as Error).message,
+        });
+        process.exit(ExitCode.ERROR);
+      }
+    });
+
+  return cmd;
+}
+
+// ============================================================================
+// Implementation
+// ============================================================================
+
+async function runRegister(
+  options: { endpoint?: string },
+  output: Output
+): Promise<void> {
+  const projectRoot = process.cwd();
+
+  // Load config
+  const config = loadConfig(projectRoot);
+  if (!config) {
+    throw new Error(
+      'ACTP not initialized. Run "actp init" first.'
+    );
+  }
+
+  if (config.mode === 'mock') {
+    throw new Error('Registration is not available in mock mode.');
+  }
+
+  // Resolve private key
+  const privateKey = await resolvePrivateKey(projectRoot);
+  if (!privateKey) {
+    throw new Error(
+      'No wallet found. Run "actp init" first to generate a wallet.'
+    );
+  }
+
+  // Parse AGIRAILS.md for service descriptors
+  const { parseAgirailsMd } = await import('../../config/agirailsmd');
+  const { extractRegistrationParams } = await import('../../config/publishPipeline');
+
+  const agirailsMdPath = path.join(projectRoot, 'AGIRAILS.md');
+  let endpoint = options.endpoint || '';
+  let serviceDescriptors;
+
+  if (fs.existsSync(agirailsMdPath)) {
+    const content = fs.readFileSync(agirailsMdPath, 'utf-8');
+    const parsed = parseAgirailsMd(content);
+    const regParams = extractRegistrationParams(parsed.frontmatter);
+    endpoint = options.endpoint || regParams.endpoint;
+    serviceDescriptors = regParams.serviceDescriptors;
+    output.info(`Parsed ${serviceDescriptors.length} service(s) from AGIRAILS.md`);
+  } else {
+    // No AGIRAILS.md — use minimal defaults
+    const { ethers: ethersLib } = await import('ethers');
+    const serviceType = 'general';
+    serviceDescriptors = [{
+      serviceTypeHash: ethersLib.keccak256(ethersLib.toUtf8Bytes(serviceType)),
+      serviceType,
+      schemaURI: '',
+      minPrice: 0n,
+      maxPrice: 1_000_000_000n, // 1000 USDC
+      avgCompletionTime: 3600,
+      metadataCID: '',
+    }];
+    output.warning('No AGIRAILS.md found. Using default "general" service descriptor.');
+    output.info('Create AGIRAILS.md with services to customize registration.');
+  }
+
+  // Dynamic imports
+  const { ethers } = await import('ethers');
+  const { getNetwork } = await import('../../config/networks');
+  const { AutoWalletProvider } = await import('../../wallet/AutoWalletProvider');
+  const { buildRegisterAgentBatch, buildTestnetInitBatch } = await import('../../wallet/aa/TransactionBatcher');
+
+  const network = config.mode === 'testnet' ? 'base-sepolia' : 'base-mainnet';
+  const networkConfig = getNetwork(network);
+
+  if (!networkConfig.aa) {
+    throw new Error(
+      `AA configuration not available for ${config.mode}. ` +
+      'Smart Wallet registration requires AA support.'
+    );
+  }
+
+  if (!networkConfig.contracts.agentRegistry) {
+    throw new Error(
+      'AgentRegistry contract not deployed yet. Registration not available.'
+    );
+  }
+
+  const rpcUrl = networkConfig.rpcUrl;
+  const provider = new ethers.JsonRpcProvider(rpcUrl);
+  const signer = new ethers.Wallet(privateKey, provider);
+
+  output.info('Creating Smart Wallet...');
+
+  const autoWallet = await AutoWalletProvider.create({
+    signer,
+    provider,
+    chainId: networkConfig.chainId,
+    actpKernelAddress: networkConfig.contracts.actpKernel,
+    bundler: {
+      primaryUrl: networkConfig.aa.bundlerUrls.coinbase,
+      backupUrl: networkConfig.aa.bundlerUrls.pimlico,
+    },
+    paymaster: {
+      primaryUrl: networkConfig.aa.paymasterUrls.coinbase,
+      backupUrl: networkConfig.aa.paymasterUrls.pimlico,
+    },
+  });
+
+  const smartWalletAddress = autoWallet.getAddress();
+  output.info(`Smart Wallet: ${smartWalletAddress}`);
+
+  if (smartWalletAddress.toLowerCase() !== config.address.toLowerCase()) {
+    output.warning(
+      `This creates a NEW address: ${smartWalletAddress}\n` +
+      `  Your current address: ${config.address}\n` +
+      '  Old address reputation/history does NOT transfer.'
+    );
+  }
+
+  // Build batch — testnet gets register + mint, mainnet gets register only
+  let calls;
+  if (config.mode === 'testnet') {
+    output.info('Testnet mode: will register + mint 1000 test USDC in one UserOp');
+    calls = buildTestnetInitBatch({
+      agentRegistryAddress: networkConfig.contracts.agentRegistry,
+      endpoint,
+      serviceDescriptors,
+      mockUsdcAddress: networkConfig.contracts.usdc,
+      recipient: smartWalletAddress,
+      mintAmount: '1000000000', // 1000 USDC
+    });
+  } else {
+    calls = buildRegisterAgentBatch(
+      networkConfig.contracts.agentRegistry,
+      endpoint,
+      serviceDescriptors
+    );
+  }
+
+  // Convert SmartWalletCall[] to TransactionRequest[]
+  const txRequests = calls.map((c) => ({
+    to: c.target,
+    data: c.data,
+    value: c.value.toString(),
+  }));
+
+  output.info('Submitting registration (gasless UserOp)...');
+
+  const receipt = await autoWallet.sendBatchTransaction(txRequests);
+
+  if (!receipt.success) {
+    throw new Error(`Registration UserOp failed: ${receipt.hash}`);
+  }
+
+  output.success('Agent registered on AgentRegistry');
+  if (config.mode === 'testnet') {
+    output.success('Minted 1,000 test USDC to Smart Wallet');
+  }
+
+  // Update config: flip address to Smart Wallet, mark as registered
+  updateConfig({
+    address: smartWalletAddress.toLowerCase(),
+    smartWallet: smartWalletAddress.toLowerCase(),
+    registered: true,
+  }, projectRoot);
+  output.info('Config updated: address set to Smart Wallet');
+
+  output.blank();
+  output.result(
+    {
+      registered: true,
+      smartWallet: smartWalletAddress,
+      services: serviceDescriptors.length,
+      txHash: receipt.hash,
+      ...(config.mode === 'testnet' && { mintedUSDC: '1000' }),
+    },
+    { quietKey: 'smartWallet' }
+  );
+
+  output.blank();
+  output.print('Your agent now has gas-free transactions!');
+  output.print(`Smart Wallet address: ${smartWalletAddress}`);
+  output.print('');
+  output.print('To use gas-free mode, add to your agent config:');
+  output.print('  wallet: "auto"');
+}

package/src/cli/index.ts

@@ -51,6 +51,7 @@ import { createTimeCommand } from './commands/time';
 import { createPublishCommand } from './commands/publish';
 import { createPullCommand } from './commands/pull';
 import { createDiffCommand } from './commands/diff';
+import { createRegisterCommand } from './commands/register';
 
 // ============================================================================
 // Program Setup
@@ -100,6 +101,9 @@ program.addCommand(createPublishCommand());
 program.addCommand(createPullCommand());
 program.addCommand(createDiffCommand());
 
+// AIP-12: Gas-free registration
+program.addCommand(createRegisterCommand());
+
 // ============================================================================
 // Error Handling
 // ============================================================================

package/src/cli/utils/config.ts

@@ -35,6 +35,15 @@ export interface CLIConfig {
   /** Optional: RPC URL override */
   rpcUrl?: string;
 
+  /** AIP-12: Wallet type — 'auto' (Smart Wallet, gasless) or 'eoa' (traditional) */
+  wallet?: 'auto' | 'eoa';
+
+  /** AIP-12: Smart Wallet address (set when wallet=auto, used by `actp register`) */
+  smartWallet?: string;
+
+  /** AIP-12: Whether agent is registered on AgentRegistry */
+  registered?: boolean;
+
   /** Configuration version for migrations */
   version: string;
 }