@oneshot-agent/sdk 0.6.2 → 0.8.0

package/dist/index.js

@@ -1,8 +1,49 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OneShot = exports.EmergencyNumberError = exports.ContentBlockedError = exports.ValidationError = exports.JobTimeoutError = exports.JobError = exports.ToolError = exports.OneShotError = exports.PROD_ENV = exports.TEST_ENV = void 0;
+exports.OneShot = exports.EmergencyNumberError = exports.ContentBlockedError = exports.ValidationError = exports.JobTimeoutError = exports.JobError = exports.ToolError = exports.OneShotError = exports.PROD_ENV = exports.TEST_ENV = exports.executeSwap = exports.getSwapQuote = exports.CdpWalletProvider = exports.EthersWalletProvider = void 0;
 const ethers_1 = require("ethers");
-const SDK_VERSION = '0.5.0';
+const ethers_2 = require("./providers/ethers");
+var ethers_3 = require("./providers/ethers");
+Object.defineProperty(exports, "EthersWalletProvider", { enumerable: true, get: function () { return ethers_3.EthersWalletProvider; } });
+var cdp_1 = require("./providers/cdp");
+Object.defineProperty(exports, "CdpWalletProvider", { enumerable: true, get: function () { return cdp_1.CdpWalletProvider; } });
+var swap_1 = require("./swap");
+Object.defineProperty(exports, "getSwapQuote", { enumerable: true, get: function () { return swap_1.getSwapQuote; } });
+Object.defineProperty(exports, "executeSwap", { enumerable: true, get: function () { return swap_1.executeSwap; } });
+const SDK_VERSION = '0.7.0';
 // ============================================================================
 // Environment Configuration
 // ============================================================================
@@ -95,10 +136,42 @@ exports.EmergencyNumberError = EmergencyNumberError;
  * ```
  */
 class OneShot {
-    constructor(config) {
-        if (!config.privateKey) {
-            throw new ValidationError('privateKey is required', 'privateKey');
+    /**
+     * Async factory — required for CDP wallets (account creation is async).
+     * Also works with privateKey and custom walletProvider.
+     *
+     * @example
+     * ```typescript
+     * // CDP wallet (no private keys)
+     * const agent = await OneShot.create({ cdp: true });
+     *
+     * // Raw private key (still works)
+     * const agent = await OneShot.create({ privateKey: '0x...' });
+     * ```
+     */
+    static async create(config) {
+        if (config.walletProvider) {
+            return new OneShot(config, config.walletProvider);
         }
+        if (config.cdp) {
+            const { CdpWalletProvider } = await Promise.resolve().then(() => __importStar(require('./providers/cdp')));
+            const cdpOpts = typeof config.cdp === 'object' ? config.cdp : undefined;
+            const walletProvider = await CdpWalletProvider.create(cdpOpts);
+            return new OneShot(config, walletProvider);
+        }
+        if (config.privateKey) {
+            const env = (config.testMode ?? true) ? exports.TEST_ENV : exports.PROD_ENV;
+            const rpcProvider = new ethers_1.ethers.JsonRpcProvider(config.rpcUrl ?? env.rpcUrl);
+            const walletProvider = new ethers_2.EthersWalletProvider(config.privateKey, rpcProvider);
+            return new OneShot(config, walletProvider);
+        }
+        throw new ValidationError('Provide one of: privateKey, cdp, or walletProvider', 'config');
+    }
+    /**
+     * Sync constructor — works with privateKey (backwards compatible).
+     * For CDP wallets, use OneShot.create() instead.
+     */
+    constructor(config, walletProvider) {
         this._testMode = config.testMode ?? true;
         const env = this._testMode ? exports.TEST_ENV : exports.PROD_ENV;
         this.baseUrl = config.baseUrl ?? env.baseUrl;
@@ -106,17 +179,31 @@ class OneShot {
         this._usdcAddress = env.usdcAddress;
         this.debug = config.debug ?? false;
         this.logger = config.logger ?? console.log;
-        const provider = new ethers_1.ethers.JsonRpcProvider(config.rpcUrl ?? env.rpcUrl);
-        this.wallet = new ethers_1.ethers.Wallet(config.privateKey, provider);
+        this.rpcProvider = new ethers_1.ethers.JsonRpcProvider(config.rpcUrl ?? env.rpcUrl);
+        this._currency = config.currency ?? 'USDC';
+        this._slippage = config.slippage ?? 0.01;
+        if (walletProvider) {
+            this.provider = walletProvider;
+        }
+        else if (config.privateKey) {
+            this.provider = new ethers_2.EthersWalletProvider(config.privateKey, this.rpcProvider);
+        }
+        else {
+            throw new ValidationError('Provide privateKey or use OneShot.create() for CDP/custom wallets', 'config');
+        }
+        // Validate ETH mode requirements
+        if (this._currency === 'ETH' && !this.provider.sendTransaction) {
+            throw new ValidationError('ETH currency mode requires a wallet provider that supports sendTransaction', 'currency');
+        }
         if (this.debug) {
-            this.log(`SDK initialized [${this._testMode ? 'TEST' : 'PROD'}] chain=${this._expectedChainId}`);
+            this.log(`SDK initialized [${this._testMode ? 'TEST' : 'PROD'}] chain=${this._expectedChainId} currency=${this._currency}`);
         }
     }
     // ---------------------------------------------------------------------------
     // Public getters
     // ---------------------------------------------------------------------------
     get address() {
-        return this.wallet.address;
+        return this.provider.address;
     }
     get isTestMode() {
         return this._testMode;
@@ -127,6 +214,12 @@ class OneShot {
     get expectedChainId() {
         return this._expectedChainId;
     }
+    get currency() {
+        return this._currency;
+    }
+    get slippage() {
+        return this._slippage;
+    }
     // ---------------------------------------------------------------------------
     // Public methods
     // ---------------------------------------------------------------------------
@@ -183,6 +276,37 @@ class OneShot {
         this.validate(options.email, 'email');
         return this.tool('verify/email', { ...options });
     }
+    async deepResearchPerson(options) {
+        if (!options.email && !options.social_media_url && !options.name) {
+            throw new ValidationError('At least one of email, social_media_url, or name is required', 'identifier');
+        }
+        return this.tool('research/person', { ...options });
+    }
+    async socialProfiles(options) {
+        if (!options.email && !options.social_media_url) {
+            throw new ValidationError('At least one of email or social_media_url is required', 'identifier');
+        }
+        return this.tool('research/social', { ...options });
+    }
+    async articleSearch(options) {
+        this.validate(options.name, 'name');
+        this.validate(options.company, 'company');
+        return this.tool('research/articles', { ...options });
+    }
+    async personNewsfeed(options) {
+        this.validate(options.social_media_url, 'social_media_url');
+        return this.tool('research/newsfeed', { ...options });
+    }
+    async personInterests(options) {
+        if (!options.email && !options.phone && !options.social_media_url) {
+            throw new ValidationError('At least one of email, phone, or social_media_url is required', 'identifier');
+        }
+        return this.tool('research/interests', { ...options });
+    }
+    async personInteractions(options) {
+        this.validate(options.social_media_url, 'social_media_url');
+        return this.tool('research/interactions', { ...options });
+    }
     async inboxList(options = {}) {
         const params = new URLSearchParams();
         if (options.since)
@@ -223,7 +347,8 @@ class OneShot {
             quantity: options.quantity ?? 1,
             variant_id: options.variant_id
         };
-        const quoteResp = await this.makeRequest('/v1/tools/commerce/buy', payload, undefined, undefined, options.signal);
+        // Commerce quotes can take up to 90s due to Rye API polling
+        const quoteResp = await this.makeRequest('/v1/tools/commerce/buy', payload, undefined, undefined, options.signal, 120000);
         if (quoteResp.status !== 402) {
             throw new ToolError('Expected 402 for quote', quoteResp.status, await quoteResp.text());
         }
@@ -243,14 +368,14 @@ class OneShot {
         };
         this.checkAbortBeforePayment(options.signal);
         const auth = await this.signPaymentAuthorization(paymentInfo);
-        const buyResp = await this.makeRequest('/v1/tools/commerce/buy', payload, auth, quoteData.context.quote_id, options.signal);
+        const buyResp = await this.makeRequest('/v1/tools/commerce/buy', payload, auth, quoteData.context.quote_id, options.signal, 60000);
         if (buyResp.status !== 202) {
             throw new ToolError('Commerce buy failed', buyResp.status, await buyResp.text());
         }
         const result = await buyResp.json();
         this.log(`Order submitted: ${result.request_id}`);
         if (options.wait !== false && result.request_id) {
-            return this.pollJob(result.request_id, options.timeout, options.signal, options.onStatusUpdate);
+            return this.pollJob(result.request_id, options.timeout ?? 180, options.signal, options.onStatusUpdate);
         }
         return result;
     }
@@ -258,6 +383,14 @@ class OneShot {
         this.validate(options.query, 'query');
         return this.tool('commerce/search', { ...options, limit: options.limit ?? 10 });
     }
+    async webSearch(options) {
+        this.validate(options.query, 'query');
+        return this.tool('search', { ...options, max_results: options.max_results ?? 5 });
+    }
+    async webRead(options) {
+        this.validate(options.url, 'url');
+        return this.tool('web-read', { ...options });
+    }
     /**
      * Make an autonomous voice call
      *
@@ -501,6 +634,78 @@ class OneShot {
         }
         return result;
     }
+    /**
+     * Automate a browser task using natural language
+     *
+     * @example
+     * ```typescript
+     * const result = await agent.browser({
+     *   task: 'Go to CoinGecko and find the current price of Bitcoin',
+     *   start_url: 'https://www.coingecko.com',
+     * });
+     * console.log(result.output);
+     * ```
+     */
+    async browser(options) {
+        this.validate(options.task, 'task');
+        if (options.task.length < 10) {
+            throw new ValidationError('Task must be at least 10 characters', 'task');
+        }
+        if (options.max_steps && (options.max_steps < 1 || options.max_steps > 100)) {
+            throw new ValidationError('max_steps must be between 1 and 100', 'max_steps');
+        }
+        const payload = {
+            task: options.task,
+            signal: options.signal,
+            onStatusUpdate: options.onStatusUpdate,
+            wait: options.wait
+        };
+        if (options.output_schema)
+            payload.output_schema = options.output_schema;
+        if (options.start_url)
+            payload.start_url = options.start_url;
+        if (options.allowed_domains)
+            payload.allowed_domains = options.allowed_domains;
+        if (options.session_id)
+            payload.session_id = options.session_id;
+        if (options.max_steps)
+            payload.max_steps = options.max_steps;
+        // Browser uses quote-to-pay flow (402 -> payment -> 202)
+        const quoteResp = await this.makeRequest('/v1/tools/browser', payload, undefined, undefined, options.signal);
+        if (quoteResp.status === 400) {
+            const errorData = await quoteResp.json();
+            throw new ValidationError(errorData.message || 'Invalid request', 'request');
+        }
+        if (quoteResp.status !== 402) {
+            throw new ToolError('Expected 402 for quote', quoteResp.status, await quoteResp.text());
+        }
+        const quoteData = await quoteResp.json();
+        this.log(`Browser quote: $${quoteData.context.estimated_cost} for ~${quoteData.context.estimated_steps} steps`);
+        if (options.maxCost && parseFloat(quoteData.context.estimated_cost) > options.maxCost) {
+            throw new OneShotError(`Quote $${quoteData.context.estimated_cost} exceeds maxCost $${options.maxCost}`);
+        }
+        const paymentInfo = {
+            protocol: 'x402',
+            network: `eip155:${quoteData.payment_request.chain_id}`,
+            payTo: quoteData.payment_request.recipient,
+            amount: quoteData.payment_request.amount,
+            currency: 'USD',
+            facilitator_url: this.baseUrl,
+            token: { address: quoteData.payment_request.token_address, symbol: 'USDC', decimals: 6 }
+        };
+        this.checkAbortBeforePayment(options.signal);
+        const auth = await this.signPaymentAuthorization(paymentInfo);
+        const execResp = await this.makeRequest('/v1/tools/browser', payload, auth, quoteData.context.quote_id, options.signal);
+        if (execResp.status !== 202) {
+            throw new ToolError('Browser task initiation failed', execResp.status, await execResp.text());
+        }
+        const result = await execResp.json();
+        this.log(`Browser task initiated: ${result.request_id}`);
+        if (options.wait !== false && result.request_id) {
+            return this.pollJob(result.request_id, options.timeout ?? 300, options.signal, options.onStatusUpdate);
+        }
+        return result;
+    }
     /**
      * Update an existing website build
      *
@@ -623,14 +828,118 @@ class OneShot {
     }
     async getBalance(tokenAddress) {
         this.validate(tokenAddress, 'tokenAddress');
-        const contract = new ethers_1.ethers.Contract(tokenAddress, ['function balanceOf(address) view returns (uint256)', 'function decimals() view returns (uint8)'], this.wallet);
+        const contract = new ethers_1.ethers.Contract(tokenAddress, ['function balanceOf(address) view returns (uint256)', 'function decimals() view returns (uint8)'], this.rpcProvider);
         const [balance, decimals] = await Promise.all([
-            contract.balanceOf(this.wallet.address),
+            contract.balanceOf(this.provider.address),
             contract.decimals()
         ]);
         return ethers_1.ethers.formatUnits(balance, decimals);
     }
     // ---------------------------------------------------------------------------
+    // Analytics methods
+    // ---------------------------------------------------------------------------
+    /**
+     * Get spend breakdown by category
+     *
+     * @example
+     * ```typescript
+     * const breakdown = await agent.spendBreakdown({ period: 30 });
+     * console.log(`Total: $${breakdown.total}`);
+     * for (const cat of breakdown.categories) {
+     *   console.log(`${cat.category}: $${cat.total} (${cat.pct}%)`);
+     * }
+     * ```
+     */
+    async spendBreakdown(options) {
+        const params = new URLSearchParams();
+        if (options?.period)
+            params.set('period', String(options.period));
+        const qs = params.toString();
+        const response = await fetch(`${this.baseUrl}/v1/analytics/spend/breakdown${qs ? `?${qs}` : ''}`, {
+            headers: this.headers()
+        });
+        if (!response.ok) {
+            throw new ToolError('Failed to get spend breakdown', response.status, await response.text());
+        }
+        return response.json();
+    }
+    /**
+     * Get Return on Cognitive Spend (RoCS)
+     *
+     * @example
+     * ```typescript
+     * const result = await agent.rocs({ period: 30 });
+     * console.log(`RoCS: ${result.rocs}x (spent $${result.total_spend}, generated $${result.total_value})`);
+     * ```
+     */
+    async rocs(options) {
+        const params = new URLSearchParams();
+        if (options?.period)
+            params.set('period', String(options.period));
+        const qs = params.toString();
+        const response = await fetch(`${this.baseUrl}/v1/analytics/rocs${qs ? `?${qs}` : ''}`, {
+            headers: this.headers()
+        });
+        if (!response.ok) {
+            throw new ToolError('Failed to get RoCS', response.status, await response.text());
+        }
+        return response.json();
+    }
+    /**
+     * List receipts with optional filtering
+     *
+     * @example
+     * ```typescript
+     * const result = await agent.receiptsList({ period: 7, category: 'communication' });
+     * for (const r of result.receipts) {
+     *   console.log(`${r.subcategory}: $${r.amount_usdc}`);
+     * }
+     * ```
+     */
+    async receiptsList(options) {
+        const params = new URLSearchParams();
+        if (options?.period)
+            params.set('period', String(options.period));
+        if (options?.category)
+            params.set('category', options.category);
+        if (options?.limit)
+            params.set('limit', String(options.limit));
+        const qs = params.toString();
+        const response = await fetch(`${this.baseUrl}/v1/analytics/receipts${qs ? `?${qs}` : ''}`, {
+            headers: this.headers()
+        });
+        if (!response.ok) {
+            throw new ToolError('Failed to list receipts', response.status, await response.text());
+        }
+        return response.json();
+    }
+    /**
+     * Tag a receipt with a value for RoCS computation
+     *
+     * @example
+     * ```typescript
+     * await agent.tagReceiptValue('rcpt_01HX...', { type: 'revenue', amount: 5.00, label: 'Sale from lead' });
+     * ```
+     */
+    async tagReceiptValue(receiptId, valueTag) {
+        this.validate(receiptId, 'receiptId');
+        this.validate(valueTag.type, 'valueTag.type');
+        const response = await fetch(`${this.baseUrl}/v1/analytics/receipts/${receiptId}/value`, {
+            method: 'PATCH',
+            headers: {
+                'Content-Type': 'application/json',
+                ...this.headers()
+            },
+            body: JSON.stringify(valueTag)
+        });
+        if (response.status === 404) {
+            throw new ToolError('Receipt not found', 404, 'Receipt not found or not owned by this agent');
+        }
+        if (!response.ok) {
+            throw new ToolError('Failed to tag receipt value', response.status, await response.text());
+        }
+    }
+    // ---------------------------------------------------------------------------
     // Private helpers
     // ---------------------------------------------------------------------------
     log(msg) {
@@ -643,7 +952,7 @@ class OneShot {
     }
     headers() {
         return {
-            'X-Agent-ID': this.wallet.address,
+            'X-Agent-ID': this.provider.address,
             'X-OneShot-SDK-Version': SDK_VERSION
         };
     }
@@ -685,6 +994,82 @@ class OneShot {
         return (result.data ?? result);
     }
     async pollJob(requestId, timeoutSec, signal, onStatusUpdate) {
+        // Try WebSocket push first, fall back to HTTP polling
+        try {
+            return await this.waitViaWebSocket(requestId, timeoutSec, signal, onStatusUpdate);
+        }
+        catch {
+            this.log('WebSocket unavailable, falling back to HTTP polling');
+            return this.pollJobHttp(requestId, timeoutSec, signal, onStatusUpdate);
+        }
+    }
+    waitViaWebSocket(requestId, timeoutSec, signal, onStatusUpdate) {
+        return new Promise((resolve, reject) => {
+            const maxWaitMs = (timeoutSec ?? 120) * 1000;
+            const wsUrl = this.baseUrl.replace(/^http/, 'ws') +
+                `/v1/requests/subscribe?wallet=${encodeURIComponent(this.provider.address)}`;
+            let ws;
+            try {
+                ws = new WebSocket(wsUrl);
+            }
+            catch {
+                return reject(new Error('WebSocket not available'));
+            }
+            const timeout = setTimeout(() => {
+                ws.close();
+                reject(new JobTimeoutError(requestId, maxWaitMs));
+            }, maxWaitMs);
+            const cleanup = () => {
+                clearTimeout(timeout);
+                if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+                    ws.close();
+                }
+            };
+            if (signal) {
+                signal.addEventListener('abort', () => {
+                    cleanup();
+                    reject(new OneShotError('Operation cancelled'));
+                }, { once: true });
+            }
+            ws.onopen = () => {
+                ws.send(JSON.stringify({ subscribe: [requestId] }));
+            };
+            ws.onmessage = (event) => {
+                try {
+                    const msg = JSON.parse(typeof event.data === 'string' ? event.data : event.data.toString());
+                    if (msg.request_id !== requestId)
+                        return;
+                    if (msg.status === 'completed') {
+                        this.log('Job completed (WebSocket)');
+                        cleanup();
+                        resolve((msg.result ?? msg));
+                    }
+                    else if (msg.status === 'failed') {
+                        cleanup();
+                        reject(new JobError(`Job failed: ${msg.error ?? 'Unknown'}`, requestId, String(msg.error ?? 'Unknown')));
+                    }
+                    else {
+                        onStatusUpdate?.(msg.status, requestId);
+                    }
+                }
+                catch {
+                    // Ignore malformed messages
+                }
+            };
+            ws.onerror = () => {
+                cleanup();
+                reject(new Error('WebSocket error'));
+            };
+            ws.onclose = (event) => {
+                // If closed before we got a result, reject so HTTP fallback kicks in
+                if (event.code !== 1000) {
+                    cleanup();
+                    reject(new Error('WebSocket closed unexpectedly'));
+                }
+            };
+        });
+    }
+    async pollJobHttp(requestId, timeoutSec, signal, onStatusUpdate) {
         const maxWaitMs = (timeoutSec ?? 120) * 1000;
         const startTime = Date.now();
         const pollInterval = 2000;
@@ -739,7 +1124,7 @@ class OneShot {
             signal?.addEventListener('abort', onAbort, { once: true });
         });
     }
-    async makeRequest(endpoint, data, payment, quoteId, signal) {
+    async makeRequest(endpoint, data, payment, quoteId, signal, timeoutMs) {
         const headers = {
             'Content-Type': 'application/json',
             ...this.headers()
@@ -748,19 +1133,47 @@ class OneShot {
             headers['x-payment'] = JSON.stringify(payment);
         if (quoteId)
             headers['x-quote-id'] = quoteId;
-        return fetch(`${this.baseUrl}${endpoint}`, {
-            method: 'POST',
-            headers,
-            body: JSON.stringify(data),
-            signal
-        });
+        // Create timeout signal if specified
+        let fetchSignal = signal;
+        let timeoutId;
+        if (timeoutMs && !signal) {
+            const controller = new AbortController();
+            timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+            fetchSignal = controller.signal;
+        }
+        try {
+            return await fetch(`${this.baseUrl}${endpoint}`, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(data),
+                signal: fetchSignal
+            });
+        }
+        finally {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+        }
     }
     checkAbortBeforePayment(signal) {
         if (signal?.aborted) {
             throw new OneShotError('Operation cancelled before payment');
         }
     }
+    /**
+     * If currency is ETH, swap ETH→USDC to ensure the wallet has enough USDC for payment.
+     * This is called before signing the x402 payment authorization.
+     */
+    async ensureUsdcBalance(paymentInfo) {
+        if (this._currency !== 'ETH')
+            return;
+        const { executeSwap } = await Promise.resolve().then(() => __importStar(require('./swap')));
+        this.log(`Swapping ETH→USDC for ${paymentInfo.amount} USDC (slippage: ${this._slippage * 100}%)`);
+        const result = await executeSwap(this.provider, this.rpcProvider, paymentInfo.amount, this._expectedChainId, this._slippage);
+        this.log(`Swap complete: tx=${result.txHash}, USDC received=${ethers_1.ethers.formatUnits(result.usdcReceived, 6)}`);
+    }
     async signPaymentAuthorization(paymentInfo) {
+        // If paying with ETH, swap to USDC first
+        await this.ensureUsdcBalance(paymentInfo);
         const now = Math.floor(Date.now() / 1000);
         const nonce = ethers_1.ethers.randomBytes(32);
         const value = ethers_1.ethers.parseUnits(paymentInfo.amount, paymentInfo.token.decimals);
@@ -772,8 +1185,8 @@ class OneShot {
         if (chainId !== this._expectedChainId) {
             console.warn(`[OneShot] Chain mismatch: API returned ${chainId}, expected ${this._expectedChainId} (${this._testMode ? 'test' : 'prod'})`);
         }
-        const signature = await this.wallet.signTypedData({
-            name: 'USD Coin', // EIP-712 domain name from USDC contract (not the ticker symbol)
+        const signature = await this.provider.signTypedData({
+            name: chainId === 84532 ? 'USDC' : 'USD Coin', // Base Sepolia uses "USDC", Base Mainnet uses "USD Coin"
             version: '2',
             chainId,
             verifyingContract: paymentInfo.token.address
@@ -787,7 +1200,7 @@ class OneShot {
                 { name: 'nonce', type: 'bytes32' }
             ]
         }, {
-            from: this.wallet.address,
+            from: this.provider.address,
             to: paymentInfo.payTo,
             value,
             validAfter: now - 300, // Buffer for clock skew
@@ -796,7 +1209,7 @@ class OneShot {
         });
         const sig = ethers_1.ethers.Signature.from(signature);
         return {
-            from: this.wallet.address,
+            from: this.provider.address,
             to: paymentInfo.payTo,
             value: value.toString(),
             validAfter: now - 300,