web3agent 0.1.0 → 0.2.0

package/dist/chunk-ETI3ZR2C.js

@@ -0,0 +1,90 @@
+import {
+  getConfig
+} from "./chunk-7QEKU2RP.js";
+
+// src/agdp/api.ts
+var AGDP_DEFAULT_URL = "https://acpx.virtuals.io/api";
+function getAgdpBaseUrl() {
+  try {
+    const config = getConfig();
+    return config.agdpApiUrl ?? AGDP_DEFAULT_URL;
+  } catch {
+    return AGDP_DEFAULT_URL;
+  }
+}
+function flattenResponse(body) {
+  if (!body || typeof body !== "object") return [];
+  const b = body;
+  if (Array.isArray(b.data)) {
+    return b.data.map((item) => {
+      if (typeof item === "object" && item !== null && "attributes" in item) {
+        const { id, attributes } = item;
+        return { id, ...attributes };
+      }
+      return item;
+    });
+  }
+  if (Array.isArray(body)) {
+    return body;
+  }
+  return [];
+}
+async function agdpFetch(path, options) {
+  const baseUrl = getAgdpBaseUrl();
+  const response = await fetch(`${baseUrl}${path}`, {
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options?.headers
+    }
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`aGDP API error ${response.status}: ${text}`);
+  }
+  return response.json();
+}
+async function searchOfferings(params) {
+  const { query = "", topK = 10 } = params;
+  const qs = new URLSearchParams({
+    query,
+    topK: String(topK),
+    searchMode: "hybrid"
+  });
+  const body = await agdpFetch(`/agents/v5/search?${qs.toString()}`);
+  if (Array.isArray(body)) return body;
+  return flattenResponse(body);
+}
+async function getOfferingById(offeringId, cachedAgents) {
+  const agents = cachedAgents ?? await searchOfferings({ topK: 500 });
+  return agents.find((a) => String(a.id) === String(offeringId)) ?? null;
+}
+async function getJobs(params) {
+  const { walletAddress, status = "active" } = params;
+  const endpoint = status === "completed" ? "/acp/jobs/completed" : "/acp/jobs/active";
+  const qs = new URLSearchParams({ walletAddress });
+  const body = await agdpFetch(`${endpoint}?${qs.toString()}`);
+  if (Array.isArray(body)) return body;
+  return flattenResponse(body);
+}
+async function createJobViaApi(params) {
+  return agdpFetch("/acp/jobs", {
+    method: "POST",
+    body: JSON.stringify(params)
+  });
+}
+async function createOfferingViaApi(_params) {
+  throw new Error(
+    "aGDP offering creation requires authenticated API access. Use the aGDP CLI instead: npx virtuals-protocol-acp sell create"
+  );
+}
+
+export {
+  AGDP_DEFAULT_URL,
+  getAgdpBaseUrl,
+  searchOfferings,
+  getOfferingById,
+  getJobs,
+  createJobViaApi,
+  createOfferingViaApi
+};

package/dist/chunk-KPRIUALX.js

@@ -0,0 +1,251 @@
+import {
+  getChainById,
+  getConfig
+} from "./chunk-7QEKU2RP.js";
+
+// src/config/wallet-factory.ts
+import { http, createWalletClient } from "viem";
+var RELIABLE_FALLBACK_RPCS = {
+  56: "https://bsc-dataseed.bnbchain.org"
+};
+function getTransportForChain(chainId, config) {
+  const resolvedConfig = config ?? getConfig();
+  const perChainUrl = resolvedConfig.chainRpcUrls[chainId];
+  if (perChainUrl) return http(perChainUrl);
+  if (resolvedConfig.rpcUrl && chainId === resolvedConfig.chainId) {
+    return http(resolvedConfig.rpcUrl);
+  }
+  const fallback = RELIABLE_FALLBACK_RPCS[chainId];
+  if (fallback) return http(fallback);
+  return http();
+}
+function createWalletClientForChain(account, chainId, config) {
+  const chain = getChainById(chainId);
+  if (!chain) {
+    throw new Error(`Unsupported chain ID: ${chainId}`);
+  }
+  return createWalletClient({ account, chain, transport: getTransportForChain(chainId, config) });
+}
+
+// src/wallet/persistence.ts
+import { existsSync } from "fs";
+import { mkdir, open, readFile, rename, unlink } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { generatePrivateKey, mnemonicToAccount, privateKeyToAccount } from "viem/accounts";
+
+// src/wallet/events.ts
+import { EventEmitter } from "events";
+var WalletEventEmitter = class extends EventEmitter {
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+};
+var walletEvents = new WalletEventEmitter();
+
+// src/wallet/persistence.ts
+var currentState = {
+  mode: "read-only",
+  chainId: 1,
+  accountIndex: 0,
+  addressIndex: 0
+};
+var currentAccount = null;
+function getWalletDir() {
+  return join(homedir(), ".web3agent");
+}
+function getWalletPath() {
+  return join(getWalletDir(), "wallet.json");
+}
+function getConfiguredChainId() {
+  try {
+    return getConfig().chainId;
+  } catch (_error) {
+    return currentState.chainId;
+  }
+}
+function getWalletState() {
+  return {
+    ...currentState,
+    chainId: getConfiguredChainId()
+  };
+}
+function getActiveAccount() {
+  if (!currentAccount) {
+    throw new Error("Wallet not initialized \u2014 call initializeWallet() first");
+  }
+  return currentAccount;
+}
+function resolveFromPrivateKey(privateKey, chainId) {
+  const account = privateKeyToAccount(privateKey);
+  return {
+    account,
+    state: {
+      mode: "private-key",
+      address: account.address,
+      chainId,
+      accountIndex: 0,
+      addressIndex: 0
+    }
+  };
+}
+function resolveFromMnemonic(mnemonic, chainId, accountIndex, addressIndex) {
+  const account = mnemonicToAccount(mnemonic, {
+    accountIndex,
+    addressIndex
+  });
+  return {
+    account,
+    state: {
+      mode: "mnemonic",
+      address: account.address,
+      chainId,
+      accountIndex,
+      addressIndex
+    }
+  };
+}
+function resolveEphemeral(chainId) {
+  const key = generatePrivateKey();
+  const account = privateKeyToAccount(key);
+  return {
+    account,
+    state: {
+      mode: "read-only",
+      address: account.address,
+      chainId,
+      accountIndex: 0,
+      addressIndex: 0
+    }
+  };
+}
+async function tryLoadPersistedWallet(chainId, accountIndex, addressIndex) {
+  const walletPath = getWalletPath();
+  const tmpPath = `${walletPath}.tmp`;
+  if (existsSync(tmpPath)) {
+    try {
+      await unlink(tmpPath);
+    } catch {
+    }
+  }
+  if (!existsSync(walletPath)) return null;
+  try {
+    const raw = await readFile(walletPath, "utf-8");
+    const data = JSON.parse(raw);
+    if (data.type === "private-key") {
+      return resolveFromPrivateKey(data.privateKey, chainId);
+    }
+    if (data.type === "mnemonic") {
+      return resolveFromMnemonic(
+        data.mnemonic,
+        chainId,
+        data.accountIndex ?? accountIndex,
+        data.addressIndex ?? addressIndex
+      );
+    }
+  } catch {
+  }
+  return null;
+}
+async function initializeWallet(config) {
+  const { chainId, accountIndex, addressIndex } = config;
+  const envKey = config.privateKey;
+  if (envKey) {
+    const resolved = resolveFromPrivateKey(envKey, chainId);
+    currentAccount = resolved.account;
+    currentState = resolved.state;
+    walletEvents.emit("wallet-changed", currentState);
+    return;
+  }
+  const envMnemonic = config.mnemonic;
+  if (envMnemonic) {
+    const resolved = resolveFromMnemonic(envMnemonic, chainId, accountIndex, addressIndex);
+    currentAccount = resolved.account;
+    currentState = resolved.state;
+    walletEvents.emit("wallet-changed", currentState);
+    return;
+  }
+  const persisted = await tryLoadPersistedWallet(chainId, accountIndex, addressIndex);
+  if (persisted) {
+    currentAccount = persisted.account;
+    currentState = persisted.state;
+    walletEvents.emit("wallet-changed", currentState);
+    return;
+  }
+  const ephemeral = resolveEphemeral(chainId);
+  currentAccount = ephemeral.account;
+  currentState = ephemeral.state;
+  walletEvents.emit("wallet-changed", currentState);
+}
+async function ensureWalletDir() {
+  const dir = getWalletDir();
+  if (!existsSync(dir)) {
+    await mkdir(dir, { recursive: true });
+  }
+}
+async function persistWallet(data) {
+  await ensureWalletDir();
+  const walletPath = getWalletPath();
+  const tmpPath = `${walletPath}.tmp`;
+  const fd = await open(tmpPath, "w", 384);
+  try {
+    await fd.writeFile(JSON.stringify(data, null, 2));
+    await fd.sync();
+  } finally {
+    await fd.close();
+  }
+  await rename(tmpPath, walletPath);
+}
+async function activateWallet(params) {
+  const chainId = getConfiguredChainId();
+  const accountIndex = params.accountIndex ?? 0;
+  const addressIndex = params.addressIndex ?? 0;
+  if (params.privateKey) {
+    const resolved = resolveFromPrivateKey(params.privateKey, chainId);
+    await persistWallet({
+      type: "private-key",
+      privateKey: params.privateKey,
+      address: resolved.account.address
+    });
+    currentAccount = resolved.account;
+    currentState = resolved.state;
+  } else if (params.mnemonic) {
+    const resolved = resolveFromMnemonic(params.mnemonic, chainId, accountIndex, addressIndex);
+    await persistWallet({
+      type: "mnemonic",
+      mnemonic: params.mnemonic,
+      accountIndex,
+      addressIndex
+    });
+    currentAccount = resolved.account;
+    currentState = resolved.state;
+  } else {
+    throw new Error("Either privateKey or mnemonic must be provided");
+  }
+  walletEvents.emit("wallet-changed", currentState);
+  return getWalletState();
+}
+async function deactivateWallet() {
+  const walletPath = getWalletPath();
+  if (existsSync(walletPath)) {
+    await unlink(walletPath);
+  }
+  const ephemeral = resolveEphemeral(getConfiguredChainId());
+  currentAccount = ephemeral.account;
+  currentState = ephemeral.state;
+  walletEvents.emit("wallet-changed", currentState);
+}
+
+export {
+  getTransportForChain,
+  createWalletClientForChain,
+  walletEvents,
+  getWalletState,
+  getActiveAccount,
+  initializeWallet,
+  activateWallet,
+  deactivateWallet
+};