@agentxpay/sdk 0.1.0

package/src/modules/payments.ts

@@ -0,0 +1,96 @@
+import { ethers } from "ethers";
+import PaymentManagerABI from "../abi/PaymentManager.json";
+import { PaymentResult } from "../types";
+
+export class PaymentsModule {
+  private contract: ethers.Contract | null = null;
+  private address: string;
+  private signerOrProvider: ethers.Signer | ethers.Provider;
+
+  constructor(address: string, signerOrProvider: ethers.Signer | ethers.Provider) {
+    this.address = address;
+    this.signerOrProvider = signerOrProvider;
+    if (address && address !== "") {
+      this.contract = new ethers.Contract(address, PaymentManagerABI, signerOrProvider);
+    }
+  }
+
+  private getContract(): ethers.Contract {
+    if (!this.contract) {
+      throw new Error("PaymentManager contract address not configured");
+    }
+    return this.contract;
+  }
+
+  async payPerUse(serviceId: bigint, amount: bigint): Promise<PaymentResult> {
+    const contract = this.getContract();
+    const tx = await contract.payPerUse(serviceId, { value: amount });
+    const receipt = await tx.wait();
+    return {
+      txHash: receipt.hash,
+      serviceId,
+      amount,
+      provider: "",
+    };
+  }
+
+  async batchPay(serviceIds: bigint[], totalAmount: bigint): Promise<string> {
+    const contract = this.getContract();
+    const tx = await contract.batchPay(serviceIds, { value: totalAmount });
+    const receipt = await tx.wait();
+    return receipt.hash;
+  }
+
+  async deposit(amount: bigint): Promise<string> {
+    const contract = this.getContract();
+    const tx = await contract.deposit({ value: amount });
+    const receipt = await tx.wait();
+    return receipt.hash;
+  }
+
+  async withdraw(amount: bigint): Promise<string> {
+    const contract = this.getContract();
+    const tx = await contract.withdraw(amount);
+    const receipt = await tx.wait();
+    return receipt.hash;
+  }
+
+  async payFromBalance(serviceId: bigint): Promise<string> {
+    const contract = this.getContract();
+    const tx = await contract.payFromBalance(serviceId);
+    const receipt = await tx.wait();
+    return receipt.hash;
+  }
+
+  async withdrawProviderEarnings(): Promise<string> {
+    const contract = this.getContract();
+    const tx = await contract.withdrawProviderEarnings();
+    const receipt = await tx.wait();
+    return receipt.hash;
+  }
+
+  async getUserBalance(address: string): Promise<bigint> {
+    const contract = this.getContract();
+    return contract.getUserBalance(address);
+  }
+
+  async getProviderEarnings(address: string): Promise<bigint> {
+    const contract = this.getContract();
+    return contract.getProviderEarnings(address);
+  }
+
+  async getPaymentCount(address: string): Promise<bigint> {
+    const contract = this.getContract();
+    return contract.getPaymentCount(address);
+  }
+
+  async getTotalSpent(address: string): Promise<bigint> {
+    const contract = this.getContract();
+    return contract.getTotalSpent(address);
+  }
+
+  getContractAddress(): string {
+    const contract = this.getContract();
+    return contract.target as string;
+  }
+}

package/src/modules/services.ts

@@ -0,0 +1,97 @@
+import { ethers } from "ethers";
+import ServiceRegistryABI from "../abi/ServiceRegistry.json";
+import { Service, SubscriptionPlan, DiscoverFilter } from "../types";
+
+export class ServicesModule {
+  private contract: ethers.Contract;
+
+  constructor(address: string, signerOrProvider: ethers.Signer | ethers.Provider) {
+    this.contract = new ethers.Contract(address, ServiceRegistryABI, signerOrProvider);
+  }
+
+  async registerService(
+    name: string,
+    description: string,
+    endpoint: string,
+    category: string,
+    pricePerCall: bigint
+  ): Promise<{ txHash: string; serviceId: bigint }> {
+    const tx = await this.contract.registerService(name, description, endpoint, category, pricePerCall);
+    const receipt = await tx.wait();
+    const event = receipt.logs.find(
+      (log: any) => this.contract.interface.parseLog(log)?.name === "ServiceRegistered"
+    );
+    const parsed = event ? this.contract.interface.parseLog(event) : null;
+    const serviceId = parsed ? parsed.args[0] : 0n;
+    return { txHash: receipt.hash, serviceId };
+  }
+
+  async addSubscriptionPlan(
+    serviceId: bigint,
+    name: string,
+    price: bigint,
+    duration: bigint
+  ): Promise<{ txHash: string; planId: bigint }> {
+    const tx = await this.contract.addSubscriptionPlan(serviceId, name, price, duration);
+    const receipt = await tx.wait();
+    return { txHash: receipt.hash, planId: 0n };
+  }
+
+  async getServiceDetails(serviceId: bigint): Promise<Service> {
+    const s = await this.contract.getServiceDetails(serviceId);
+    return this._mapService(s);
+  }
+
+  async discoverServices(filter?: DiscoverFilter): Promise<Service[]> {
+    if (filter?.category) {
+      const services = await this.contract.getServicesByCategory(filter.category);
+      let result = services.map((s: any) => this._mapService(s));
+      if (filter.maxPrice) {
+        result = result.filter((s: Service) => s.pricePerCall <= filter.maxPrice!);
+      }
+      return result;
+    }
+
+    const count = await this.contract.getServiceCount();
+    const services: Service[] = [];
+    for (let i = 1n; i <= count; i++) {
+      const s = await this.contract.getServiceDetails(i).catch(() => null);
+      if (s && s.isActive) {
+        const service = this._mapService(s);
+        if (!filter?.maxPrice || service.pricePerCall <= filter.maxPrice) {
+          services.push(service);
+        }
+      }
+    }
+    return services;
+  }
+
+  async getSubscriptionPlans(serviceId: bigint): Promise<SubscriptionPlan[]> {
+    const plans = await this.contract.getSubscriptionPlans(serviceId);
+    return plans.map((p: any) => ({
+      planId: p.planId,
+      serviceId: p.serviceId,
+      price: p.price,
+      duration: p.duration,
+      name: p.name,
+    }));
+  }
+
+  async getServiceCount(): Promise<bigint> {
+    return this.contract.getServiceCount();
+  }
+
+  private _mapService(s: any): Service {
+    return {
+      id: s.id,
+      provider: s.provider,
+      name: s.name,
+      description: s.description,
+      endpoint: s.endpoint,
+      category: s.category,
+      pricePerCall: s.pricePerCall,
+      isActive: s.isActive,
+      createdAt: s.createdAt,
+    };
+  }
+}

package/src/modules/subscriptions.ts

@@ -0,0 +1,78 @@
+import { ethers } from "ethers";
+import SubscriptionManagerABI from "../abi/SubscriptionManager.json";
+import { Subscription } from "../types";
+
+export class SubscriptionsModule {
+  private contract: ethers.Contract | null = null;
+
+  constructor(address: string, signerOrProvider: ethers.Signer | ethers.Provider) {
+    if (address && address !== "") {
+      this.contract = new ethers.Contract(address, SubscriptionManagerABI, signerOrProvider);
+    }
+  }
+
+  private getContract(): ethers.Contract {
+    if (!this.contract) {
+      throw new Error("SubscriptionManager contract address not configured");
+    }
+    return this.contract;
+  }
+
+  async subscribe(serviceId: bigint, planId: bigint, amount: bigint): Promise<{ txHash: string; subscriptionId: bigint }> {
+    const contract = this.getContract();
+    const tx = await contract.subscribe(serviceId, planId, { value: amount });
+    const receipt = await tx.wait();
+    return { txHash: receipt.hash, subscriptionId: 0n };
+  }
+
+  async cancelSubscription(subscriptionId: bigint): Promise<string> {
+    const contract = this.getContract();
+    const tx = await contract.cancelSubscription(subscriptionId);
+    const receipt = await tx.wait();
+    return receipt.hash;
+  }
+
+  async renewSubscription(subscriptionId: bigint, amount: bigint): Promise<string> {
+    const contract = this.getContract();
+    const tx = await contract.renewSubscription(subscriptionId, { value: amount });
+    const receipt = await tx.wait();
+    return receipt.hash;
+  }
+
+  async toggleAutoRenew(subscriptionId: bigint): Promise<string> {
+    const contract = this.getContract();
+    const tx = await contract.toggleAutoRenew(subscriptionId);
+    const receipt = await tx.wait();
+    return receipt.hash;
+  }
+
+  async getSubscription(subscriptionId: bigint): Promise<Subscription> {
+    const contract = this.getContract();
+    const s = await contract.getSubscription(subscriptionId);
+    return {
+      subscriptionId: s.subscriptionId,
+      serviceId: s.serviceId,
+      planId: s.planId,
+      subscriber: s.subscriber,
+      startTime: s.startTime,
+      endTime: s.endTime,
+      autoRenew: s.autoRenew,
+      isActive: s.isActive,
+    };
+  }
+
+  async getUserSubscriptions(address: string): Promise<bigint[]> {
+    const contract = this.getContract();
+    return contract.getUserSubscriptions(address);
+  }
+
+  async isActive(subscriptionId: bigint): Promise<boolean> {
+    const contract = this.getContract();
+    return contract.isSubscriptionActive(subscriptionId);
+  }
+
+  async checkAccess(userAddress: string, serviceId: bigint): Promise<boolean> {
+    const contract = this.getContract();
+    return contract.checkAccess(userAddress, serviceId);
+  }
+}

package/src/modules/wallet.ts

@@ -0,0 +1,111 @@
+import { ethers } from "ethers";
+import AgentWalletABI from "../abi/AgentWallet.json";
+import AgentWalletFactoryABI from "../abi/AgentWalletFactory.json";
+
+export class WalletModule {
+  private factoryContract: ethers.Contract | null = null;
+  private signerOrProvider: ethers.Signer | ethers.Provider;
+
+  constructor(factoryAddress: string, signerOrProvider: ethers.Signer | ethers.Provider) {
+    if (factoryAddress && factoryAddress !== "") {
+      this.factoryContract = new ethers.Contract(factoryAddress, AgentWalletFactoryABI, signerOrProvider);
+    }
+    this.signerOrProvider = signerOrProvider;
+  }
+
+  private getContract(): ethers.Contract {
+    if (!this.factoryContract) {
+      throw new Error("AgentWalletFactory contract address not configured");
+    }
+    return this.factoryContract;
+  }
+
+  async createWallet(dailyLimit: bigint): Promise<{ txHash: string; walletAddress: string }> {
+    const contract = this.getContract();
+    const tx = await contract.createWallet(dailyLimit);
+    const receipt = await tx.wait();
+    const event = receipt.logs.find(
+      (log: any) => contract.interface.parseLog(log)?.name === "WalletCreated"
+    );
+    const parsed = event ? contract.interface.parseLog(event) : null;
+    const walletAddress = parsed ? parsed.args[1] : "";
+    return { txHash: receipt.hash, walletAddress };
+  }
+
+  async getWallets(owner: string): Promise<string[]> {
+    const contract = this.getContract();
+    return contract.getWallets(owner);
+  }
+
+  getWalletInstance(walletAddress: string): AgentWalletClient {
+    return new AgentWalletClient(walletAddress, this.signerOrProvider);
+  }
+}
+
+export class AgentWalletClient {
+  private contract: ethers.Contract;
+
+  constructor(address: string, signerOrProvider: ethers.Signer | ethers.Provider) {
+    this.contract = new ethers.Contract(address, AgentWalletABI, signerOrProvider);
+  }
+
+  async execute(to: string, value: bigint, data: string = "0x"): Promise<string> {
+    const tx = await this.contract.execute(to, value, data);
+    const receipt = await tx.wait();
+    return receipt.hash;
+  }
+
+  async setDailySpendingLimit(limit: bigint): Promise<string> {
+    const tx = await this.contract.setDailySpendingLimit(limit);
+    const receipt = await tx.wait();
+    return receipt.hash;
+  }
+
+  async authorizeAgent(agent: string): Promise<string> {
+    const tx = await this.contract.authorizeAgent(agent);
+    const receipt = await tx.wait();
+    return receipt.hash;
+  }
+
+  async revokeAgent(agent: string): Promise<string> {
+    const tx = await this.contract.revokeAgent(agent);
+    const receipt = await tx.wait();
+    return receipt.hash;
+  }
+
+  async withdrawFunds(amount: bigint): Promise<string> {
+    const tx = await this.contract.withdrawFunds(amount);
+    const receipt = await tx.wait();
+    return receipt.hash;
+  }
+
+  async deposit(amount: bigint): Promise<string> {
+    const signer = this.contract.runner as ethers.Signer;
+    const tx = await signer.sendTransaction({
+      to: await this.contract.getAddress(),
+      value: amount,
+    });
+    const receipt = await tx.wait();
+    return receipt!.hash;
+  }
+
+  async isAuthorizedAgent(agent: string): Promise<boolean> {
+    return this.contract.isAuthorizedAgent(agent);
+  }
+
+  async getDailySpendingLimit(): Promise<bigint> {
+    return this.contract.getDailySpendingLimit();
+  }
+
+  async getDailySpent(): Promise<bigint> {
+    return this.contract.getDailySpent();
+  }
+
+  async getRemainingDailyAllowance(): Promise<bigint> {
+    return this.contract.getRemainingDailyAllowance();
+  }
+
+  async getOwner(): Promise<string> {
+    return this.contract.getOwner();
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,93 @@
+export interface AgentXPayConfig {
+  rpcUrl: string;
+  privateKey?: string;
+  signer?: any; // ethers.Signer
+  contracts?: ContractAddresses;
+  network?: "local" | "testnet" | "mainnet";
+}
+
+export interface ContractAddresses {
+  serviceRegistry?: string;
+  paymentManager?: string;
+  subscriptionManager?: string;
+  escrow?: string;
+  agentWalletFactory?: string;
+}
+
+export interface Service {
+  id: bigint;
+  provider: string;
+  name: string;
+  description: string;
+  endpoint: string;
+  category: string;
+  pricePerCall: bigint;
+  isActive: boolean;
+  createdAt: bigint;
+}
+
+export interface SubscriptionPlan {
+  planId: bigint;
+  serviceId: bigint;
+  price: bigint;
+  duration: bigint;
+  name: string;
+}
+
+export interface Subscription {
+  subscriptionId: bigint;
+  serviceId: bigint;
+  planId: bigint;
+  subscriber: string;
+  startTime: bigint;
+  endTime: bigint;
+  autoRenew: boolean;
+  isActive: boolean;
+}
+
+export enum EscrowStatus {
+  Created = 0,
+  Funded = 1,
+  Released = 2,
+  Disputed = 3,
+  Refunded = 4,
+  Resolved = 5,
+}
+
+export interface EscrowData {
+  escrowId: bigint;
+  serviceId: bigint;
+  payer: string;
+  provider: string;
+  amount: bigint;
+  status: EscrowStatus;
+  createdAt: bigint;
+  deadline: bigint;
+  description: string;
+}
+
+export interface DiscoverFilter {
+  category?: string;
+  maxPrice?: bigint;
+  isActive?: boolean;
+}
+
+export interface PaymentResult {
+  txHash: string;
+  serviceId: bigint;
+  amount: bigint;
+  provider: string;
+}
+
+export interface X402PaymentInfo {
+  address: string;
+  amount: string;
+  token: string;
+  serviceId: string;
+  chainId: string;
+}
+
+export interface X402FetchOptions extends RequestInit {
+  autoPayment?: boolean;
+  maxRetries?: number;
+}

package/src/utils/constants.ts

@@ -0,0 +1,25 @@
+import { ContractAddresses } from "../types";
+
+export const MONAD_TESTNET_CHAIN_ID = 10143;
+export const MONAD_TESTNET_RPC = "https://testnet-rpc.monad.xyz/";
+
+export const DEFAULT_CONTRACTS: Record<string, ContractAddresses> = {
+  local: {
+    serviceRegistry: "",
+    paymentManager: "",
+    subscriptionManager: "",
+    escrow: "",
+    agentWalletFactory: "",
+  },
+  testnet: {
+    serviceRegistry: "",
+    paymentManager: "",
+    subscriptionManager: "",
+    escrow: "",
+    agentWalletFactory: "",
+  },
+};
+
+export const DEFAULT_GAS_LIMIT = 500000n;
+export const MAX_RETRIES = 3;
+export const RETRY_DELAY_MS = 1000;

package/src/utils/helpers.ts

@@ -0,0 +1,30 @@
+import { ethers } from "ethers";
+
+export function shortenAddress(address: string, chars = 4): string {
+  return `${address.slice(0, chars + 2)}...${address.slice(-chars)}`;
+}
+
+export function formatEther(wei: bigint): string {
+  return ethers.formatEther(wei);
+}
+
+export function parseEther(ether: string): bigint {
+  return ethers.parseEther(ether);
+}
+
+export function isValidAddress(address: string): boolean {
+  return ethers.isAddress(address);
+}
+
+export async function waitForTx(
+  tx: ethers.TransactionResponse,
+  confirmations = 1
+): Promise<ethers.TransactionReceipt> {
+  const receipt = await tx.wait(confirmations);
+  if (!receipt) throw new Error("Transaction receipt is null");
+  return receipt;
+}
+
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}