amped-defi 1.0.0

package/src/wallet/backends/BankrWalletProvider.ts

@@ -0,0 +1,329 @@
+/**
+ * Bankr Wallet Provider for SODAX SDK
+ * 
+ * Implements IEvmWalletProvider interface to allow SODAX SDK
+ * to execute transactions through Bankr's API.
+ * 
+ * Instead of signing locally, transactions are submitted to Bankr
+ * which signs and broadcasts them server-side.
+ * 
+ * Supported chains: Ethereum (1), Polygon (137), Base (8453)
+ */
+
+import type { Address, Hash, PublicClient } from 'viem';
+import { createPublicClient, http } from 'viem';
+import { mainnet, polygon, base } from 'viem/chains';
+import type { 
+  IEvmWalletProvider, 
+  EvmRawTransaction, 
+  EvmRawTransactionReceipt 
+} from '@sodax/types';
+
+/**
+ * Chain configurations for Bankr
+ */
+const BANKR_CHAINS: Record<number, { chain: any; name: string }> = {
+  1: { chain: mainnet, name: 'ethereum' },
+  137: { chain: polygon, name: 'polygon' },
+  8453: { chain: base, name: 'base' },
+};
+
+/**
+ * Bankr API response types
+ */
+interface BankrJobSubmitResponse {
+  success: boolean;
+  jobId: string;
+  status: 'pending';
+  message?: string;
+  error?: string;
+}
+
+interface BankrJobStatusResponse {
+  success: boolean;
+  jobId: string;
+  status: 'pending' | 'processing' | 'completed' | 'failed' | 'cancelled';
+  prompt: string;
+  response?: string;
+  error?: string;
+  richData?: Array<{ 
+    type?: string;
+    transactionHash?: string;
+    txHash?: string;
+    hash?: string;
+    [key: string]: unknown;
+  }>;
+  statusUpdates?: Array<{ message: string; timestamp: string }>;
+}
+
+/**
+ * Configuration for BankrWalletProvider
+ */
+export interface BankrWalletProviderConfig {
+  apiKey: string;
+  apiUrl?: string;
+  chainId: number;
+  rpcUrl?: string;
+  /** Pre-cached address (avoids initial API call) */
+  cachedAddress?: Address;
+}
+
+/**
+ * Bankr Wallet Provider
+ * 
+ * Implements IEvmWalletProvider for use with SODAX SDK's SpokeProvider.
+ * Transactions are signed and broadcast via Bankr's Agent API.
+ */
+export class BankrWalletProvider implements IEvmWalletProvider {
+  readonly publicClient: PublicClient;
+  
+  private readonly apiUrl: string;
+  private readonly apiKey: string;
+  private readonly chainId: number;
+  private cachedAddress: Address | null;
+  
+  // Polling configuration
+  private readonly pollIntervalMs = 2000;
+  private readonly maxPollAttempts = 150; // 5 minutes max
+
+  constructor(config: BankrWalletProviderConfig) {
+    this.apiKey = config.apiKey;
+    this.apiUrl = config.apiUrl || 'https://api.bankr.bot';
+    this.chainId = config.chainId;
+    this.cachedAddress = config.cachedAddress || null;
+    
+    // Validate chain support
+    const chainConfig = BANKR_CHAINS[config.chainId];
+    if (!chainConfig) {
+      throw new Error(
+        `Bankr does not support chainId ${config.chainId}. ` +
+        `Supported: Ethereum (1), Polygon (137), Base (8453)`
+      );
+    }
+    
+    // Create public client for read operations
+    this.publicClient = createPublicClient({
+      chain: chainConfig.chain,
+      transport: http(config.rpcUrl),
+    }) as PublicClient;
+    
+    console.log(`[BankrWalletProvider] Initialized for ${chainConfig.name} (${config.chainId})`);
+  }
+
+  /**
+   * Get the Bankr wallet address
+   */
+  async getWalletAddress(): Promise<Address> {
+    if (this.cachedAddress) return this.cachedAddress;
+    
+    console.log('[BankrWalletProvider] Fetching wallet address from Bankr...');
+    
+    try {
+      const response = await this.submitAndWait('What is my EVM wallet address?');
+      
+      // Extract address from response
+      const addressMatch = response.match(/0x[a-fA-F0-9]{40}/);
+      if (!addressMatch) {
+        throw new Error('Could not parse wallet address from Bankr response');
+      }
+      
+      this.cachedAddress = addressMatch[0] as Address;
+      console.log(`[BankrWalletProvider] Wallet address: ${this.cachedAddress}`);
+      
+      return this.cachedAddress;
+    } catch (error) {
+      console.error('[BankrWalletProvider] Failed to get address:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Send a transaction via Bankr
+   * 
+   * This is the key method - it receives raw transaction data from SODAX SDK
+   * and submits it to Bankr for signing and broadcasting.
+   */
+  async sendTransaction(evmRawTx: EvmRawTransaction): Promise<Hash> {
+    console.log('[BankrWalletProvider] Sending transaction via Bankr');
+    console.log(`[BankrWalletProvider] To: ${evmRawTx.to}`);
+    console.log(`[BankrWalletProvider] Value: ${evmRawTx.value}`);
+    console.log(`[BankrWalletProvider] Data: ${evmRawTx.data.slice(0, 20)}...`);
+
+    // Format transaction for Bankr's arbitrary transaction endpoint
+    const txJson = JSON.stringify({
+      to: evmRawTx.to,
+      data: evmRawTx.data,
+      value: evmRawTx.value.toString(),
+      chainId: this.chainId,
+    }, null, 2);
+
+    // Use the documented prompt format
+    const prompt = `Submit this transaction:
+${txJson}`;
+
+    console.log('[BankrWalletProvider] Submitting to Bankr API...');
+    
+    const result = await this.submitAndWaitForJob(prompt);
+    
+    // Extract transaction hash from response
+    const txHash = this.extractTransactionHash(result);
+    
+    if (!txHash) {
+      const errorMsg = result.error || result.response || 'Unknown error';
+      throw new Error(`Transaction failed: ${errorMsg}`);
+    }
+
+    console.log(`[BankrWalletProvider] Transaction hash: ${txHash}`);
+    return txHash;
+  }
+
+  /**
+   * Wait for transaction receipt
+   * 
+   * Uses the public client to query the blockchain directly.
+   */
+  async waitForTransactionReceipt(txHash: Hash): Promise<EvmRawTransactionReceipt> {
+    console.log(`[BankrWalletProvider] Waiting for receipt: ${txHash}`);
+    
+    const receipt = await this.publicClient.waitForTransactionReceipt({
+      hash: txHash,
+      timeout: 120_000, // 2 minutes
+    });
+
+    // Convert viem receipt to SODAX format
+    return {
+      transactionHash: receipt.transactionHash,
+      transactionIndex: `0x${receipt.transactionIndex.toString(16)}`,
+      blockHash: receipt.blockHash,
+      blockNumber: `0x${receipt.blockNumber.toString(16)}`,
+      from: receipt.from,
+      to: receipt.to,
+      cumulativeGasUsed: `0x${receipt.cumulativeGasUsed.toString(16)}`,
+      gasUsed: `0x${receipt.gasUsed.toString(16)}`,
+      contractAddress: receipt.contractAddress,
+      logs: receipt.logs.map(log => ({
+        address: log.address as Address,
+        topics: (log as any).topics || [],
+        data: log.data,
+        blockHash: log.blockHash,
+        blockNumber: log.blockNumber ? `0x${log.blockNumber.toString(16)}` : null,
+        logIndex: log.logIndex !== null ? `0x${log.logIndex.toString(16)}` : null,
+        transactionHash: log.transactionHash,
+        transactionIndex: log.transactionIndex !== null ? `0x${log.transactionIndex.toString(16)}` : null,
+        removed: log.removed,
+      })) as any,
+      logsBloom: receipt.logsBloom,
+      status: receipt.status === 'success' ? '0x1' : '0x0',
+      type: receipt.type,
+      effectiveGasPrice: receipt.effectiveGasPrice ? `0x${receipt.effectiveGasPrice.toString(16)}` : undefined,
+    };
+  }
+
+  /**
+   * Submit prompt and wait for text response
+   */
+  private async submitAndWait(prompt: string): Promise<string> {
+    const result = await this.submitAndWaitForJob(prompt);
+    return result.response || '';
+  }
+
+  /**
+   * Submit prompt and wait for job completion
+   */
+  private async submitAndWaitForJob(prompt: string): Promise<BankrJobStatusResponse> {
+    // Submit job
+    const submitResponse = await fetch(`${this.apiUrl}/agent/prompt`, {
+      method: 'POST',
+      headers: {
+        'X-API-Key': this.apiKey,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ prompt }),
+    });
+
+    if (!submitResponse.ok) {
+      const error = await submitResponse.text();
+      throw new Error(`Failed to submit job: ${submitResponse.status} ${error}`);
+    }
+
+    const submitData = await submitResponse.json() as BankrJobSubmitResponse;
+    
+    if (!submitData.success || !submitData.jobId) {
+      throw new Error(`Invalid job response: ${JSON.stringify(submitData)}`);
+    }
+
+    const jobId = submitData.jobId;
+    console.log(`[BankrWalletProvider] Job submitted: ${jobId}`);
+
+    // Poll for completion
+    let lastStatus = '';
+    
+    for (let attempt = 0; attempt < this.maxPollAttempts; attempt++) {
+      await this.sleep(this.pollIntervalMs);
+      
+      const statusResponse = await fetch(`${this.apiUrl}/agent/job/${jobId}`, {
+        method: 'GET',
+        headers: { 'X-API-Key': this.apiKey },
+      });
+
+      if (!statusResponse.ok) {
+        const error = await statusResponse.text();
+        throw new Error(`Failed to get job status: ${statusResponse.status} ${error}`);
+      }
+
+      const result = await statusResponse.json() as BankrJobStatusResponse;
+      
+      // Log status changes
+      if (result.status !== lastStatus) {
+        console.log(`[BankrWalletProvider] Job ${jobId}: ${result.status}`);
+        lastStatus = result.status;
+      }
+
+      // Check terminal states
+      switch (result.status) {
+        case 'completed':
+          return result;
+        case 'failed':
+          throw new Error(`Job failed: ${result.error || 'Unknown error'}`);
+        case 'cancelled':
+          throw new Error(`Job was cancelled`);
+      }
+    }
+
+    throw new Error(`Job ${jobId} timed out`);
+  }
+
+  /**
+   * Extract transaction hash from Bankr response
+   */
+  private extractTransactionHash(result: BankrJobStatusResponse): Hash | null {
+    // Check richData for transaction info
+    if (result.richData) {
+      for (const item of result.richData) {
+        if (item.transactionHash) return item.transactionHash as Hash;
+        if (item.txHash) return item.txHash as Hash;
+        if (item.hash) return item.hash as Hash;
+      }
+    }
+
+    // Try to extract from response text
+    if (result.response) {
+      // Look for 0x + 64 hex chars
+      const hashMatch = result.response.match(/0x[a-fA-F0-9]{64}/);
+      if (hashMatch) return hashMatch[0] as Hash;
+    }
+
+    return null;
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}
+
+/**
+ * Create a BankrWalletProvider
+ */
+export function createBankrWalletProvider(config: BankrWalletProviderConfig): BankrWalletProvider {
+  return new BankrWalletProvider(config);
+}

package/src/wallet/backends/EnvBackend.ts

@@ -0,0 +1,149 @@
+/**
+ * Environment Variable Backend
+ * 
+ * Loads wallet from environment variables:
+ * - AMPED_OC_WALLETS_JSON: JSON with wallet configs
+ * - Or individual env vars for address/privateKey
+ */
+
+import type { Address } from 'viem';
+import type { IWalletBackend } from '../types';
+import { SODAX_SUPPORTED_CHAINS } from '../types';
+
+/**
+ * Wallet entry from AMPED_OC_WALLETS_JSON
+ */
+interface EnvWalletEntry {
+  address: string;
+  privateKey: string;
+}
+
+/**
+ * Environment variable backend configuration
+ */
+export interface EnvBackendConfig {
+  nickname: string;
+  address?: Address;
+  privateKey?: `0x${string}`;
+  envVar?: string;  // Name of env var containing JSON
+  chains?: string[];
+}
+
+/**
+ * Environment variable wallet backend
+ * Supports all SODAX chains (local key signing)
+ */
+export class EnvBackend implements IWalletBackend {
+  readonly type = 'env' as const;
+  readonly nickname: string;
+  readonly supportedChains: readonly string[];
+  
+  private address: Address | null = null;
+  private privateKey: `0x${string}` | null = null;
+  private envVar: string | null = null;
+
+  constructor(config: EnvBackendConfig) {
+    this.nickname = config.nickname;
+    this.supportedChains = config.chains || [...SODAX_SUPPORTED_CHAINS];
+    
+    if (config.address && config.privateKey) {
+      // Direct address/key provided
+      this.address = config.address;
+      this.privateKey = config.privateKey;
+    } else if (config.envVar) {
+      // Will load from env var
+      this.envVar = config.envVar;
+    }
+  }
+
+  /**
+   * Load wallet from environment variable if needed
+   */
+  private loadFromEnv(): { address: Address; privateKey: `0x${string}` } {
+    if (this.address && this.privateKey) {
+      return { address: this.address, privateKey: this.privateKey };
+    }
+
+    if (this.envVar) {
+      const envValue = process.env[this.envVar];
+      if (!envValue) {
+        throw new Error(`Environment variable ${this.envVar} not set`);
+      }
+      
+      try {
+        const data = JSON.parse(envValue) as EnvWalletEntry;
+        this.address = data.address as Address;
+        this.privateKey = (data.privateKey.startsWith('0x') 
+          ? data.privateKey 
+          : `0x${data.privateKey}`) as `0x${string}`;
+        return { address: this.address, privateKey: this.privateKey };
+      } catch (error) {
+        throw new Error(`Failed to parse ${this.envVar}: ${error}`);
+      }
+    }
+
+    throw new Error(`No wallet configuration for "${this.nickname}"`);
+  }
+
+  async getAddress(): Promise<Address> {
+    const { address } = this.loadFromEnv();
+    return address;
+  }
+
+  supportsChain(chainId: string): boolean {
+    return this.supportedChains.includes(chainId);
+  }
+
+  async getPrivateKey(): Promise<`0x${string}`> {
+    const { privateKey } = this.loadFromEnv();
+    return privateKey;
+  }
+
+  async isReady(): Promise<boolean> {
+    try {
+      this.loadFromEnv();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+/**
+ * Create env backend from direct config
+ */
+export function createEnvBackend(config: EnvBackendConfig): EnvBackend {
+  return new EnvBackend(config);
+}
+
+/**
+ * Load wallets from AMPED_OC_WALLETS_JSON environment variable
+ * Returns multiple backends keyed by wallet name
+ */
+export function loadWalletsFromEnv(): Map<string, EnvBackend> {
+  const wallets = new Map<string, EnvBackend>();
+  
+  const walletsJson = process.env.AMPED_OC_WALLETS_JSON;
+  if (!walletsJson) return wallets;
+  
+  try {
+    const parsed = JSON.parse(walletsJson) as Record<string, EnvWalletEntry>;
+    
+    for (const [name, wallet] of Object.entries(parsed)) {
+      const backend = new EnvBackend({
+        nickname: name,
+        address: wallet.address as Address,
+        privateKey: (wallet.privateKey.startsWith('0x') 
+          ? wallet.privateKey 
+          : `0x${wallet.privateKey}`) as `0x${string}`,
+      });
+      wallets.set(name.toLowerCase(), backend);
+    }
+    
+    console.log(`[EnvBackend] Loaded ${wallets.size} wallet(s) from AMPED_OC_WALLETS_JSON`);
+  } catch (error) {
+    console.warn(`[EnvBackend] Failed to parse AMPED_OC_WALLETS_JSON: ${error}`);
+  }
+  
+  return wallets;
+}

package/src/wallet/backends/EvmWalletSkillBackend.ts

@@ -0,0 +1,110 @@
+/**
+ * EVM Wallet Skill Backend
+ * 
+ * Loads wallet from ~/.evm-wallet.json (created by evm-wallet-skill)
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import type { Address } from 'viem';
+import type { IWalletBackend } from '../types';
+import { SODAX_SUPPORTED_CHAINS } from '../types';
+
+/**
+ * Default path to evm-wallet-skill wallet file
+ */
+const DEFAULT_WALLET_PATH = join(homedir(), '.evm-wallet.json');
+
+/**
+ * EVM Wallet Skill wallet file structure
+ */
+interface EvmWalletFile {
+  address: string;
+  privateKey: string;
+}
+
+/**
+ * Backend for evm-wallet-skill wallets
+ * Supports all SODAX chains (local key signing)
+ */
+export class EvmWalletSkillBackend implements IWalletBackend {
+  readonly type = 'evm-wallet-skill' as const;
+  readonly nickname: string;
+  readonly supportedChains: readonly string[];
+  
+  private walletPath: string;
+  private cachedWallet: EvmWalletFile | null = null;
+
+  constructor(options: {
+    nickname: string;
+    path?: string;
+    chains?: string[];
+  }) {
+    this.nickname = options.nickname;
+    this.walletPath = options.path || DEFAULT_WALLET_PATH;
+    this.supportedChains = options.chains || [...SODAX_SUPPORTED_CHAINS];
+  }
+
+  /**
+   * Load wallet from file (cached)
+   */
+  private loadWallet(): EvmWalletFile {
+    if (this.cachedWallet) return this.cachedWallet;
+    
+    if (!existsSync(this.walletPath)) {
+      throw new Error(
+        `Wallet file not found: ${this.walletPath}\n` +
+        `Run: git clone https://github.com/amped-finance/evm-wallet-skill.git ~/.openclaw/skills/evm-wallet-skill\n` +
+        `     cd ~/.openclaw/skills/evm-wallet-skill && npm install && node src/setup.js`
+      );
+    }
+    
+    try {
+      const content = readFileSync(this.walletPath, 'utf-8');
+      this.cachedWallet = JSON.parse(content) as EvmWalletFile;
+      return this.cachedWallet;
+    } catch (error) {
+      throw new Error(`Failed to load wallet from ${this.walletPath}: ${error}`);
+    }
+  }
+
+  async getAddress(): Promise<Address> {
+    const wallet = this.loadWallet();
+    return wallet.address as Address;
+  }
+
+  supportsChain(chainId: string): boolean {
+    return this.supportedChains.includes(chainId);
+  }
+
+  async getPrivateKey(): Promise<`0x${string}`> {
+    const wallet = this.loadWallet();
+    const key = wallet.privateKey;
+    return key.startsWith('0x') ? key as `0x${string}` : `0x${key}` as `0x${string}`;
+  }
+
+  async isReady(): Promise<boolean> {
+    try {
+      this.loadWallet();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+/**
+ * Create an evm-wallet-skill backend
+ */
+export function createEvmWalletSkillBackend(options: {
+  nickname?: string;
+  path?: string;
+  chains?: string[];
+} = {}): EvmWalletSkillBackend {
+  return new EvmWalletSkillBackend({
+    nickname: options.nickname || 'main',
+    path: options.path,
+    chains: options.chains,
+  });
+}

package/src/wallet/backends/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Wallet Backends
+ * 
+ * Export all wallet backend implementations
+ */
+
+export { EvmWalletSkillBackend, createEvmWalletSkillBackend } from './EvmWalletSkillBackend';
+export { BankrBackend, createBankrBackend, type BankrBackendConfig } from './BankrBackend';
+export { EnvBackend, createEnvBackend, loadWalletsFromEnv, type EnvBackendConfig } from './EnvBackend';
+export { BankrWalletProvider, createBankrWalletProvider, type BankrWalletProviderConfig } from './BankrWalletProvider';

package/src/wallet/index.ts

@@ -0,0 +1,14 @@
+/**
+ * Wallet Module
+ * 
+ * Multi-source wallet management with nicknames
+ */
+
+// Types
+export * from './types';
+
+// Backends
+export * from './backends';
+
+// Manager
+export { WalletManager, getWalletManager, resetWalletManager } from './walletManager';