agent-operator 0.1.0 → 0.2.0

package/dist/config.d.ts

@@ -1,8 +1,16 @@
 import type { PoliciesConfig } from "./policies/types.js";
 import type { AlertsConfig } from "./notifications/types.js";
+export type Network = "mainnet" | "testnet";
+export interface TokenConfig {
+    address: string;
+    symbol: string;
+    decimals?: number;
+}
 export interface WalletConfig {
     walletId: string;
     chains: string[];
+    network?: Network;
+    tokens?: Record<string, TokenConfig[]>;
     policies: PoliciesConfig;
     notifications: NotificationConfig;
 }

package/dist/connectors/base.d.ts

@@ -1,6 +1,12 @@
+import type { Network, TokenConfig } from "../config.js";
 import type { Connector, Session, SessionResult, Balance } from "./types.js";
 export declare class BaseConnector implements Connector {
     chain: string;
+    network: Network;
+    tokens: TokenConfig[];
+    constructor(network?: Network, tokens?: TokenConfig[]);
+    private get chainId();
+    private getViemChain;
     private sessions;
     openSession(params: {
         service: string;
@@ -8,5 +14,5 @@ export declare class BaseConnector implements Connector {
         walletId: string;
     }): Promise<Session>;
     closeSession(sessionId: string): Promise<SessionResult>;
-    getBalance(walletId: string): Promise<Balance>;
+    getBalances(walletId: string): Promise<Balance[]>;
 }

package/dist/connectors/base.js

@@ -1,19 +1,42 @@
 import { Mppx } from "mppx/client";
 import { Method, Credential } from "mppx";
 import { signTransaction, getWallet } from "@open-wallet-standard/core";
-// Base chain ID for EIP-155
-const BASE_CHAIN_ID = "eip155:8453";
+const DEFAULT_TOKENS = {
+    mainnet: [
+        { address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", symbol: "USDC", decimals: 6 },
+    ],
+    testnet: [
+        { address: "0x036CbD53842c5426634e7929541eC2318f3dCF7e", symbol: "USDC", decimals: 6 },
+    ],
+};
+const CHAIN_IDS = {
+    mainnet: "eip155:8453",
+    testnet: "eip155:84532",
+};
 export class BaseConnector {
     chain = "base";
+    network;
+    tokens;
+    constructor(network = "mainnet", tokens) {
+        this.network = network;
+        this.tokens = tokens ?? DEFAULT_TOKENS[network];
+    }
+    get chainId() {
+        return CHAIN_IDS[this.network];
+    }
+    async getViemChain() {
+        const chains = await import("viem/chains");
+        return this.network === "testnet" ? chains.baseSepolia : chains.base;
+    }
     sessions = new Map();
     async openSession(params) {
         const { service, maxBudget, walletId } = params;
+        const chainId = this.chainId;
         const wallet = getWallet(walletId);
         const baseAccount = wallet.accounts.find((a) => a.chainId.startsWith("eip155"));
         if (!baseAccount) {
             throw new Error(`Wallet '${walletId}' has no EVM account for Base`);
         }
-        // define a custom charge method for Base
         const baseChargeMethod = Method.from({
             name: "base",
             intent: "charge",
@@ -32,26 +55,24 @@ export class BaseConnector {
         });
         const clientMethod = Method.toClient(baseChargeMethod, {
             async createCredential({ challenge }) {
-                // sign the payment via OWS (policies enforced here)
                 const txData = JSON.stringify({
                     challengeId: challenge.id,
                     from: baseAccount.address,
                     amount: challenge.request?.amount,
                     chain: "base",
                 });
-                const result = signTransaction(walletId, BASE_CHAIN_ID, txData);
+                const result = signTransaction(walletId, chainId, txData);
                 return Credential.serialize({
                     challenge,
                     payload: { signature: result.signature },
-                    source: `did:pkh:eip155:8453:${baseAccount.address}`,
+                    source: `did:pkh:${chainId}:${baseAccount.address}`,
                 });
             },
         });
         const mppxClient = Mppx.create({
             methods: [clientMethod],
         });
-        // initiate the 402 flow
-        const response = await mppxClient.fetch(service, {
+        await mppxClient.fetch(service, {
             headers: { "X-Max-Budget": String(maxBudget) },
         });
         const sessionId = crypto.randomUUID();
@@ -83,37 +104,52 @@ export class BaseConnector {
             refund: session.maxBudget - session.spent,
         };
     }
-    async getBalance(walletId) {
+    async getBalances(walletId) {
         const wallet = getWallet(walletId);
         const baseAccount = wallet.accounts.find((a) => a.chainId.startsWith("eip155"));
         if (!baseAccount) {
-            return { chain: this.chain, amount: 0, currency: "USDC" };
+            return this.tokens.map((t) => ({
+                chain: this.chain,
+                amount: 0,
+                currency: t.symbol,
+            }));
         }
         try {
             const { createPublicClient, http, parseAbi, formatUnits } = await import("viem");
-            const { base } = await import("viem/chains");
+            const chain = await this.getViemChain();
             const client = createPublicClient({
-                chain: base,
+                chain,
                 transport: http(),
             });
-            // USDC on Base
-            const USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
-            const balance = await client.readContract({
-                address: USDC_ADDRESS,
-                abi: parseAbi([
-                    "function balanceOf(address) view returns (uint256)",
-                ]),
-                functionName: "balanceOf",
-                args: [baseAccount.address],
-            });
-            return {
-                chain: this.chain,
-                amount: Number(formatUnits(balance, 6)),
-                currency: "USDC",
-            };
+            const balanceAbi = parseAbi([
+                "function balanceOf(address) view returns (uint256)",
+            ]);
+            const results = await Promise.all(this.tokens.map(async (token) => {
+                try {
+                    const balance = await client.readContract({
+                        address: token.address,
+                        abi: balanceAbi,
+                        functionName: "balanceOf",
+                        args: [baseAccount.address],
+                    });
+                    return {
+                        chain: this.chain,
+                        amount: Number(formatUnits(balance, token.decimals ?? 6)),
+                        currency: token.symbol,
+                    };
+                }
+                catch {
+                    return { chain: this.chain, amount: 0, currency: token.symbol };
+                }
+            }));
+            return results;
         }
         catch {
-            return { chain: this.chain, amount: 0, currency: "USDC" };
+            return this.tokens.map((t) => ({
+                chain: this.chain,
+                amount: 0,
+                currency: t.symbol,
+            }));
         }
     }
 }

package/dist/connectors/solana.d.ts

@@ -1,12 +1,18 @@
+import type { Network, TokenConfig } from "../config.js";
 import type { Connector, Session, SessionResult, Balance } from "./types.js";
 export declare class SolanaConnector implements Connector {
     chain: string;
+    network: Network;
+    tokens: TokenConfig[];
     private sessions;
+    constructor(network?: Network, tokens?: TokenConfig[]);
+    private get rpcUrl();
+    private get solanaChainId();
     openSession(params: {
         service: string;
         maxBudget: number;
         walletId: string;
     }): Promise<Session>;
     closeSession(sessionId: string): Promise<SessionResult>;
-    getBalance(walletId: string): Promise<Balance>;
+    getBalances(walletId: string): Promise<Balance[]>;
 }

package/dist/connectors/solana.js

@@ -1,9 +1,32 @@
 import { getWallet, signTransaction } from "@open-wallet-standard/core";
 import { solana } from "@solana/mpp/client";
 import { Mppx } from "mppx/client";
+const RPC_URLS = {
+    mainnet: "https://api.mainnet-beta.solana.com",
+    testnet: "https://api.devnet.solana.com",
+};
+const SOLANA_CHAIN_IDS = {
+    mainnet: "solana:mainnet-beta",
+    testnet: "solana:devnet",
+};
+const DEFAULT_TOKENS = [
+    { address: "native", symbol: "SOL", decimals: 9 },
+];
 export class SolanaConnector {
     chain = "solana";
+    network;
+    tokens;
     sessions = new Map();
+    constructor(network = "mainnet", tokens) {
+        this.network = network;
+        this.tokens = tokens ?? DEFAULT_TOKENS;
+    }
+    get rpcUrl() {
+        return RPC_URLS[this.network];
+    }
+    get solanaChainId() {
+        return SOLANA_CHAIN_IDS[this.network];
+    }
     async openSession(params) {
         const { service, maxBudget, walletId } = params;
         const wallet = getWallet(walletId);
@@ -11,8 +34,8 @@ export class SolanaConnector {
         if (!solanaAccount) {
             throw new Error(`Wallet '${walletId}' has no Solana account`);
         }
-        // create an OWS-backed TransactionSigner compatible with @solana/kit
         const { address } = await import("@solana/kit");
+        const solanaChainId = this.solanaChainId;
         const owsSigner = {
             address: address(solanaAccount.address),
             async signTransactions(transactions) {
@@ -21,20 +44,18 @@ export class SolanaConnector {
                         ? tx.serialize()
                         : new Uint8Array(tx);
                     const txHex = Buffer.from(txBytes).toString("hex");
-                    const result = signTransaction(walletId, "solana:mainnet-beta", txHex);
-                    // return the signed transaction bytes
+                    const result = signTransaction(walletId, solanaChainId, txHex);
                     return Buffer.from(result.signature, "hex");
                 }));
             },
         };
-        // create @solana/mpp charge method with OWS signer
         const chargeMethod = solana.charge({
             signer: owsSigner,
+            rpcUrl: this.rpcUrl,
         });
         const mppxClient = Mppx.create({
             methods: [chargeMethod],
         });
-        // initiate payment via the 402 challenge-response flow
         await mppxClient.fetch(service, {
             headers: { "X-Max-Budget": String(maxBudget) },
         });
@@ -65,27 +86,54 @@ export class SolanaConnector {
             totalSpent: session.maxBudget,
         };
     }
-    async getBalance(walletId) {
+    async getBalances(walletId) {
         const wallet = getWallet(walletId);
         const solanaAccount = wallet.accounts.find((a) => a.chainId.startsWith("solana"));
         if (!solanaAccount) {
-            return { chain: this.chain, amount: 0, currency: "USDC" };
+            return this.tokens.map((t) => ({
+                chain: this.chain,
+                amount: 0,
+                currency: t.symbol,
+            }));
         }
         try {
             const { createSolanaRpc } = await import("@solana/kit");
-            const rpc = createSolanaRpc("https://api.mainnet-beta.solana.com");
-            // get native SOL balance
-            const { value } = await rpc
-                .getBalance(solanaAccount.address)
-                .send();
-            return {
-                chain: this.chain,
-                amount: Number(value) / 1e9,
-                currency: "SOL",
-            };
+            const rpc = createSolanaRpc(this.rpcUrl);
+            const results = await Promise.all(this.tokens.map(async (token) => {
+                try {
+                    if (token.address === "native") {
+                        const { value } = await rpc
+                            .getBalance(solanaAccount.address)
+                            .send();
+                        return {
+                            chain: this.chain,
+                            amount: Number(value) / 1e9,
+                            currency: token.symbol,
+                        };
+                    }
+                    // SPL token balance
+                    const { value } = await rpc
+                        .getTokenAccountsByOwner(solanaAccount.address, { mint: token.address }, { encoding: "jsonParsed" })
+                        .send();
+                    const amount = value?.[0]?.account?.data?.parsed?.info?.tokenAmount?.uiAmount ?? 0;
+                    return {
+                        chain: this.chain,
+                        amount,
+                        currency: token.symbol,
+                    };
+                }
+                catch {
+                    return { chain: this.chain, amount: 0, currency: token.symbol };
+                }
+            }));
+            return results;
         }
         catch {
-            return { chain: this.chain, amount: 0, currency: "SOL" };
+            return this.tokens.map((t) => ({
+                chain: this.chain,
+                amount: 0,
+                currency: t.symbol,
+            }));
         }
     }
 }

package/dist/connectors/tempo.d.ts

@@ -1,12 +1,18 @@
+import type { Network, TokenConfig } from "../config.js";
 import type { Connector, Session, SessionResult, Balance } from "./types.js";
 export declare class TempoConnector implements Connector {
     chain: string;
-    private sessions;
+    network: Network;
+    tokens: TokenConfig[];
+    constructor(network?: Network, tokens?: TokenConfig[]);
+    private getChain;
+    private getChainId;
     openSession(params: {
         service: string;
         maxBudget: number;
         walletId: string;
     }): Promise<Session>;
+    private sessions;
     closeSession(sessionId: string): Promise<SessionResult>;
-    getBalance(walletId: string): Promise<Balance>;
+    getBalances(walletId: string): Promise<Balance[]>;
 }

package/dist/connectors/tempo.js

@@ -1,46 +1,58 @@
 import { tempo as tempoClient } from "mppx/client";
 import { signMessage, getWallet } from "@open-wallet-standard/core";
+const DEFAULT_TOKENS = [
+    { address: "0x20c0000000000000000000000000000000000000", symbol: "pathUSD", decimals: 6 },
+];
 export class TempoConnector {
     chain = "tempo";
-    sessions = new Map();
+    network;
+    tokens;
+    constructor(network = "mainnet", tokens) {
+        this.network = network;
+        this.tokens = tokens ?? DEFAULT_TOKENS;
+    }
+    async getChain() {
+        const chains = await import("viem/chains");
+        return this.network === "testnet" ? chains.tempoModerato : chains.tempo;
+    }
+    getChainId() {
+        // Tempo Mainnet: 4217, Testnet (Moderato): 42431
+        return this.network === "testnet" ? "eip155:42431" : "eip155:4217";
+    }
     async openSession(params) {
         const { service, maxBudget, walletId } = params;
+        const chainId = this.getChainId();
         const wallet = getWallet(walletId);
         const evmAccount = wallet.accounts.find((a) => a.chainId.startsWith("eip155"));
         if (!evmAccount) {
             throw new Error(`Wallet '${walletId}' has no EVM account for Tempo`);
         }
-        // create OWS-backed viem custom account for Tempo
         const { toAccount } = await import("viem/accounts");
-        const { createPublicClient, http } = await import("viem");
-        const { tempo: tempoChain } = await import("viem/chains");
         const owsAccount = toAccount({
             address: evmAccount.address,
             async signMessage({ message }) {
                 const msgStr = typeof message === "string"
                     ? message
                     : Buffer.from(message.raw).toString("hex");
-                const result = signMessage(walletId, "eip155:1", msgStr);
+                const result = signMessage(walletId, chainId, msgStr);
                 return result.signature;
             },
             async signTransaction(tx) {
                 const { signTransaction: owsSignTx } = await import("@open-wallet-standard/core");
                 const txHex = typeof tx === "string" ? tx : JSON.stringify(tx);
-                const result = owsSignTx(walletId, "eip155:1", txHex);
+                const result = owsSignTx(walletId, chainId, txHex);
                 return result.signature;
             },
             async signTypedData(typedData) {
                 const { signTypedData: owsSignTyped } = await import("@open-wallet-standard/core");
-                const result = owsSignTyped(walletId, "eip155:1", JSON.stringify(typedData));
+                const result = owsSignTyped(walletId, chainId, JSON.stringify(typedData));
                 return result.signature;
             },
         });
-        // create the session manager with Tempo's built-in method
         const manager = tempoClient.session({
             account: owsAccount,
             maxDeposit: String(maxBudget),
         });
-        // open the session (creates on-chain channel)
         await manager.open({ deposit: BigInt(Math.floor(maxBudget * 1e6)) });
         const sessionId = manager.channelId ?? crypto.randomUUID();
         this.sessions.set(sessionId, {
@@ -58,12 +70,13 @@ export class TempoConnector {
             status: "active",
         };
     }
+    sessions = new Map();
     async closeSession(sessionId) {
         const session = this.sessions.get(sessionId);
         if (!session) {
             throw new Error(`Session '${sessionId}' not found`);
         }
-        const receipt = await session.manager.close();
+        await session.manager.close();
         this.sessions.delete(sessionId);
         const totalSpent = Number(session.manager.cumulative) / 1e6;
         return {
@@ -72,31 +85,52 @@ export class TempoConnector {
             refund: session.maxBudget - totalSpent,
         };
     }
-    async getBalance(walletId) {
+    async getBalances(walletId) {
         const wallet = getWallet(walletId);
         const evmAccount = wallet.accounts.find((a) => a.chainId.startsWith("eip155"));
         if (!evmAccount) {
-            return { chain: this.chain, amount: 0, currency: "TEMPO" };
+            return this.tokens.map((t) => ({
+                chain: this.chain,
+                amount: 0,
+                currency: t.symbol,
+            }));
         }
         try {
-            const { createPublicClient, http, parseAbi } = await import("viem");
-            const { tempo: tempoChain } = await import("viem/chains");
+            const { createPublicClient, http, parseAbi, formatUnits } = await import("viem");
+            const chain = await this.getChain();
             const client = createPublicClient({
-                chain: tempoChain,
+                chain,
                 transport: http(),
             });
-            // query native balance
-            const balance = await client.getBalance({
-                address: evmAccount.address,
-            });
-            return {
-                chain: this.chain,
-                amount: Number(balance) / 1e18,
-                currency: "TEMPO",
-            };
+            const balanceAbi = parseAbi([
+                "function balanceOf(address) view returns (uint256)",
+            ]);
+            const results = await Promise.all(this.tokens.map(async (token) => {
+                try {
+                    const balance = await client.readContract({
+                        address: token.address,
+                        abi: balanceAbi,
+                        functionName: "balanceOf",
+                        args: [evmAccount.address],
+                    });
+                    return {
+                        chain: this.chain,
+                        amount: Number(formatUnits(balance, token.decimals ?? 6)),
+                        currency: token.symbol,
+                    };
+                }
+                catch {
+                    return { chain: this.chain, amount: 0, currency: token.symbol };
+                }
+            }));
+            return results;
         }
         catch {
-            return { chain: this.chain, amount: 0, currency: "TEMPO" };
+            return this.tokens.map((t) => ({
+                chain: this.chain,
+                amount: 0,
+                currency: t.symbol,
+            }));
         }
     }
 }

package/dist/connectors/types.d.ts

@@ -1,12 +1,15 @@
+import type { Network, TokenConfig } from "../config.js";
 export interface Connector {
     chain: string;
+    network: Network;
+    tokens: TokenConfig[];
     openSession(params: {
         service: string;
         maxBudget: number;
         walletId: string;
     }): Promise<Session>;
     closeSession(sessionId: string): Promise<SessionResult>;
-    getBalance(walletId: string): Promise<Balance>;
+    getBalances(walletId: string): Promise<Balance[]>;
 }
 export interface Session {
     sessionId: string;

package/dist/index.d.ts

@@ -2,7 +2,7 @@ import { Operator } from "./operator.js";
 export { Operator } from "./operator.js";
 export type { PayParams } from "./operator.js";
 export { loadConfig } from "./config.js";
-export type { OperatorConfig, WalletConfig, NotificationConfig } from "./config.js";
+export type { OperatorConfig, WalletConfig, NotificationConfig, TokenConfig, Network } from "./config.js";
 export type { Connector, Session, SessionResult, Balance } from "./connectors/types.js";
 export { TempoConnector } from "./connectors/tempo.js";
 export { BaseConnector } from "./connectors/base.js";

package/dist/operator.d.ts

@@ -17,7 +17,7 @@ export declare class Operator {
     start(): Promise<void>;
     shutdown(): Promise<void>;
     pay(walletName: string, params: PayParams): Promise<SessionResult>;
-    getBalance(walletName: string, chain: string): Promise<Balance>;
+    getBalances(walletName: string, chain: string): Promise<Balance[]>;
     closeSession(walletName: string, sessionId: string): Promise<SessionResult>;
     getWalletNames(): string[];
     private getWalletConfig;

package/dist/operator.js

@@ -18,24 +18,30 @@ export class Operator {
         this.initNotifications();
     }
     initConnectors() {
-        const connectorInstances = {
-            tempo: new TempoConnector(),
-            base: new BaseConnector(),
-            solana: new SolanaConnector(),
-        };
-        // register only the connectors that wallets actually use
-        const neededChains = new Set();
+        // connectors keyed by "chain:network" to support different networks per wallet
         for (const wallet of Object.values(this.config.wallets)) {
+            const network = wallet.network ?? "mainnet";
             for (const chain of wallet.chains) {
-                neededChains.add(chain);
-            }
-        }
-        for (const chain of neededChains) {
-            const connector = connectorInstances[chain];
-            if (!connector) {
-                throw new Error(`No built-in connector for chain '${chain}'`);
+                const key = `${chain}:${network}`;
+                if (this.connectors.has(key))
+                    continue;
+                const tokens = wallet.tokens?.[chain];
+                let connector;
+                switch (chain) {
+                    case "tempo":
+                        connector = new TempoConnector(network, tokens);
+                        break;
+                    case "base":
+                        connector = new BaseConnector(network, tokens);
+                        break;
+                    case "solana":
+                        connector = new SolanaConnector(network, tokens);
+                        break;
+                    default:
+                        throw new Error(`No built-in connector for chain '${chain}'`);
+                }
+                this.connectors.set(key, connector);
             }
-            this.connectors.set(chain, connector);
         }
     }
     initNotifications() {
@@ -126,17 +132,18 @@ export class Operator {
         recordSpend(walletName, params.service, params.chain, result.totalSpent);
         return result;
     }
-    async getBalance(walletName, chain) {
+    async getBalances(walletName, chain) {
         const wallet = this.getWalletConfig(walletName);
         const connector = this.getConnector(walletName, chain);
-        return connector.getBalance(wallet.walletId);
+        return connector.getBalances(wallet.walletId);
     }
     async closeSession(walletName, sessionId) {
         // find the connector that has this session
         // try all connectors for this wallet
         const wallet = this.getWalletConfig(walletName);
+        const network = wallet.network ?? "mainnet";
         for (const chain of wallet.chains) {
-            const connector = this.connectors.get(chain);
+            const connector = this.connectors.get(`${chain}:${network}`);
             if (!connector)
                 continue;
             try {
@@ -165,9 +172,11 @@ export class Operator {
         if (!wallet.chains.includes(chain)) {
             throw new Error(`Wallet '${walletName}' is not configured for chain '${chain}'. Available: ${wallet.chains.join(", ")}`);
         }
-        const connector = this.connectors.get(chain);
+        const network = wallet.network ?? "mainnet";
+        const key = `${chain}:${network}`;
+        const connector = this.connectors.get(key);
         if (!connector) {
-            throw new Error(`No connector found for chain '${chain}'`);
+            throw new Error(`No connector found for chain '${chain}' on ${network}`);
         }
         return connector;
     }
@@ -182,11 +191,14 @@ export class Operator {
                 const balances = {};
                 for (const chain of wallet.chains) {
                     try {
-                        const balance = await this.getBalance(walletName, chain);
-                        balances[chain] = balance.amount;
+                        const chainBalances = await this.getBalances(walletName, chain);
+                        balances[chain] = {};
+                        for (const b of chainBalances) {
+                            balances[chain][b.currency] = b.amount;
+                        }
                     }
                     catch {
-                        balances[chain] = -1;
+                        balances[chain] = {};
                     }
                 }
                 await this.notifications.notify(walletName, {

package/dist/policies/low-balance.js

@@ -2,19 +2,21 @@ export async function checkLowBalance(walletName, walletId, chain, lowBalanceThr
     if (lowBalanceThreshold === undefined)
         return;
     try {
-        const balance = await connector.getBalance(walletId);
-        if (balance.amount < lowBalanceThreshold) {
-            await provider.send({
-                type: "low_balance",
-                walletName,
-                chain,
-                data: {
-                    balance: balance.amount,
-                    currency: balance.currency,
-                    threshold: lowBalanceThreshold,
-                },
-                timestamp: new Date().toISOString(),
-            }).catch(() => { });
+        const balances = await connector.getBalances(walletId);
+        for (const balance of balances) {
+            if (balance.amount < lowBalanceThreshold) {
+                await provider.send({
+                    type: "low_balance",
+                    walletName,
+                    chain,
+                    data: {
+                        balance: balance.amount,
+                        currency: balance.currency,
+                        threshold: lowBalanceThreshold,
+                    },
+                    timestamp: new Date().toISOString(),
+                }).catch(() => { });
+            }
         }
     }
     catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-operator",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Drop-in toolkit for governed, observable AI agent payments",
   "type": "module",
   "main": "dist/index.js",