@dvmkit/sdk 0.1.0-rc.4 → 0.1.0-rc.6

package/dist/chunk-ANFX5HEG.js

@@ -0,0 +1,186 @@
+import {
+  isValidEvmPrivateKey,
+  loadConfig,
+  updateConfig
+} from "./chunk-TSWKITGR.js";
+import {
+  DvmError,
+  resolveRpcHttpTransportOptions,
+  resolveRpcOverride
+} from "./chunk-MKI6OVW4.js";
+import {
+  redactUrl,
+  redactUrlsInText
+} from "./chunk-FUJ36YDV.js";
+
+// src/lib/payment-rails/tempo-wallet.ts
+var TEMPO_USDC_MAINNET = "0x20C000000000000000000000b9537d11c60E8b50";
+var TEMPO_CHAIN_ID = 4217;
+function resolveTempoAsset(env = process.env) {
+  const address = env.DVM_TEMPO_CURRENCY ?? TEMPO_USDC_MAINNET;
+  if (!HEX_ADDRESS_RE.test(address)) {
+    throw new DvmError(
+      "tempo_config_invalid",
+      `DVM_TEMPO_CURRENCY must be a 0x-prefixed 40-char hex address; got '${address}'.`,
+      "Unset DVM_TEMPO_CURRENCY to fall back to the bundled USDC.e mainnet default."
+    );
+  }
+  const symbol = tempoTokenSymbol(address);
+  return {
+    address,
+    symbol,
+    label: tempoTokenLabel(address),
+    unit: symbol ?? "tokens"
+  };
+}
+function tempoTokenLabel(address) {
+  return tempoTokenSymbol(address) ?? `the token at ${shortAddress(address)}`;
+}
+function tempoTokenReference(address) {
+  const symbol = tempoTokenSymbol(address);
+  return symbol ? `${symbol} (${address})` : address;
+}
+function tempoBalanceCheckHint(token) {
+  const configured = tryResolveTempoAsset();
+  if (configured?.address.toLowerCase() === token.toLowerCase()) {
+    return "This channel's token is the rail's configured settlement asset, so 'dvm wallet balance' reads it.";
+  }
+  return `'dvm wallet balance' reads the rail's configured settlement asset (${configured?.address ?? "unresolvable in this environment"}) rather than this channel's token (${token}), so query that contract directly for the balance that matters here.`;
+}
+function tryResolveTempoAsset(env = process.env) {
+  try {
+    return resolveTempoAsset(env);
+  } catch {
+    return null;
+  }
+}
+function tempoWrongAssetHint(asset) {
+  return `This rail settles only in ${asset.label} (${asset.address}) on Tempo. Another Tempo dollar \u2014 USDT0 or any other stablecoin \u2014 is a different contract and will never show up here, however much of it your wallet says you hold. If you funded with the wrong one, swap it to ${asset.label} on Tempo (an on-chain swap, fees are sub-cent) or send ${asset.label} to this address.`;
+}
+function tempoTokenSymbol(address) {
+  return address.toLowerCase() === TEMPO_USDC_MAINNET.toLowerCase() ? "USDC.e" : null;
+}
+var HEX_ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
+async function connectedTempoAccount() {
+  const config = loadConfig();
+  return tempoAccountFromConfig(config);
+}
+async function generateTempoKey(opts = {}) {
+  const config = loadConfig();
+  if (!config) {
+    throw new DvmError(
+      "no_config",
+      "No config found.",
+      "Run `dvm init` before generating a Tempo wallet."
+    );
+  }
+  const existing = await tempoAccountFromConfig(config);
+  if (existing && !opts.force) {
+    throw new DvmError(
+      "tempo_wallet_exists",
+      `Tempo wallet already configured (address ${existing.address}).`,
+      "Pass `--force` to replace, or run `dvm wallet tempo-disconnect` to clear it first."
+    );
+  }
+  if (existing && opts.force) {
+    const { assertTempoWalletIdle } = await import("./tempo-lifecycle-SQL3KLEZ.js");
+    await assertTempoWalletIdle("replace");
+  }
+  const { privateKeyToAccount, generatePrivateKey } = await import("viem/accounts");
+  const privateKey = generatePrivateKey();
+  const account = privateKeyToAccount(privateKey);
+  const generated = {
+    privateKey,
+    address: account.address.toLowerCase()
+  };
+  await opts.beforePersist?.(generated);
+  await updateConfig({
+    reason: "tempo_wallet_generate",
+    patch: () => ({ set: { tempo: { method: "tempo", apiKey: privateKey } } })
+  });
+  return generated;
+}
+async function getTempoUsdcBalance(account) {
+  const tokenAddress = resolveTempoAsset().address;
+  const { createPublicClient, http, erc20Abi } = await import("viem");
+  const { tempo } = await import("viem/chains");
+  const { url: rpcUrl, source: rpcSource } = resolveRpcOverride(
+    process.env.DVM_TEMPO_RPC_URL,
+    tempo.rpcUrls.default.http[0]
+  );
+  try {
+    const transportOptions = resolveRpcHttpTransportOptions(
+      rpcSource,
+      process.env.DVM_TEMPO_RPC_HEADERS_JSON
+    );
+    const client = createPublicClient({
+      chain: tempo,
+      transport: transportOptions ? http(rpcUrl, transportOptions) : http(rpcUrl)
+    });
+    const raw = await client.readContract({
+      address: tokenAddress,
+      abi: erc20Abi,
+      functionName: "balanceOf",
+      args: [account.address]
+    });
+    return {
+      address: account.address,
+      rawBaseUnits: raw,
+      usdc: Number(raw) / 1e6,
+      tokenAddress,
+      chainId: TEMPO_CHAIN_ID,
+      // internal-review: redacted here rather than at a display surface, so the clear
+      // endpoint never leaves this function on the success path either.
+      rpcUrlRedacted: redactUrl(rpcUrl),
+      rpcSource,
+      fetchedAtMs: Date.now()
+    };
+  } catch (err) {
+    const cause = redactUrlsInText(err instanceof Error ? err.message : String(err));
+    throw new DvmError(
+      "tempo_rpc_error",
+      `Tempo USDC balance lookup failed: ${cause}`,
+      // A caller who set the override doesn't need to be told to set it. Which
+      // knob is theirs to turn depends on whose endpoint this was.
+      rpcSource === "override" ? `DVM_TEMPO_RPC_URL sent this read to ${redactUrl(rpcUrl)}. Correct it, or unset it to fall back to Tempo's bundled endpoint.` : `Verify connectivity to Tempo's bundled endpoint (${redactUrl(rpcUrl)}), or send the read somewhere else with DVM_TEMPO_RPC_URL.`
+    );
+  }
+}
+async function deriveTempoAddress(privateKey) {
+  if (!isValidEvmPrivateKey(privateKey)) throw invalidTempoPrivateKey();
+  const { privateKeyToAccount } = await import("viem/accounts");
+  return privateKeyToAccount(privateKey).address.toLowerCase();
+}
+function shortAddress(addr) {
+  return `${addr.slice(0, 6)}\u2026${addr.slice(-4)}`;
+}
+async function tempoAccountFromConfig(config) {
+  if (config?.tempo?.method !== "tempo") return null;
+  const apiKey = config.tempo.apiKey;
+  if (!apiKey || !isValidEvmPrivateKey(apiKey)) return null;
+  const privateKey = apiKey;
+  const address = await deriveTempoAddress(privateKey);
+  return { privateKey, address };
+}
+function invalidTempoPrivateKey() {
+  return new DvmError(
+    "invalid_api_key",
+    "A Tempo private key must be a valid 0x-prefixed 32-byte hex secp256k1 private key.",
+    "Generate one with `cast wallet new` or `openssl rand -hex 32` (and prepend 0x)."
+  );
+}
+
+export {
+  TEMPO_USDC_MAINNET,
+  TEMPO_CHAIN_ID,
+  resolveTempoAsset,
+  tempoTokenLabel,
+  tempoTokenReference,
+  tempoBalanceCheckHint,
+  tryResolveTempoAsset,
+  tempoWrongAssetHint,
+  connectedTempoAccount,
+  generateTempoKey,
+  getTempoUsdcBalance,
+  deriveTempoAddress
+};