@dvmkit/sdk 0.7.0-rc.1 → 0.7.0-rc.10

package/dist/chunk-OFVV37XC.js

@@ -1,57 +0,0 @@
-// src/lib/cast-auth/canonical-json.ts
-function canonicalize(value) {
-  return JSON.stringify(sortDeep(value));
-}
-function canonicaliseForSigning(value) {
-  return new TextEncoder().encode(canonicalize(value));
-}
-function sortDeep(value) {
-  if (value === null) return null;
-  if (typeof value === "string" || typeof value === "boolean") return value;
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) {
-      throw new TypeError(`canonicalize: non-finite number is not JSON-serialisable`);
-    }
-    return value;
-  }
-  if (Array.isArray(value)) return value.map(sortDeep);
-  if (typeof value === "object") {
-    const sorted = {};
-    for (const key of Object.keys(value).sort()) {
-      const v = value[key];
-      if (v === void 0) continue;
-      sorted[key] = sortDeep(v);
-    }
-    return sorted;
-  }
-  throw new TypeError(`canonicalize: unsupported value of type ${typeof value}`);
-}
-
-// src/lib/cast-auth/verify.ts
-import { schnorr } from "@noble/curves/secp256k1.js";
-function verifyCanonicalSignedRequest(payload, signatureHex, pubkeyHex) {
-  if (!/^[0-9a-f]{64}$/i.test(pubkeyHex) || !/^[0-9a-f]{128}$/i.test(signatureHex)) {
-    return false;
-  }
-  const data = canonicaliseForSigning(payload);
-  const signature = hexToBytes(signatureHex);
-  const pubkey = hexToBytes(pubkeyHex);
-  try {
-    return schnorr.verify(signature, data, pubkey);
-  } catch {
-    return false;
-  }
-}
-function hexToBytes(hex) {
-  const out = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < out.length; i++) {
-    out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-  }
-  return out;
-}
-
-export {
-  canonicalize,
-  canonicaliseForSigning,
-  verifyCanonicalSignedRequest
-};

package/dist/chunk-SZVXOQ75.js

@@ -1,211 +0,0 @@
-import {
-  isValidEvmPrivateKey,
-  loadConfig,
-  tempoAccountFromConfig,
-  updateConfig
-} from "./chunk-WBOKPC37.js";
-import {
-  resolveRpcHttpTransportOptions,
-  resolveRpcOverride
-} from "./chunk-CXCQLOOK.js";
-import {
-  redactUrl,
-  redactUrlsInText
-} from "./chunk-FUJ36YDV.js";
-import {
-  DvmError
-} from "./chunk-BPYMEMQX.js";
-
-// src/lib/payment-rails/tempo-wallet.ts
-var TEMPO_USDC_MAINNET = "0x20C000000000000000000000b9537d11c60E8b50";
-var TEMPO_CHAIN_ID = 4217;
-var TEMPO_MODERATO_CHAIN_ID = 42431;
-var TEMPO_PATH_USD_MODERATO = "0x20c0000000000000000000000000000000000000";
-var TEMPO_MODERATO_RPC = "https://rpc.moderato.tempo.xyz";
-function resolveTempoNetwork(network = "mainnet") {
-  return network === "moderato" ? {
-    network,
-    chainId: TEMPO_MODERATO_CHAIN_ID,
-    rpcUrl: TEMPO_MODERATO_RPC,
-    defaultToken: TEMPO_PATH_USD_MODERATO
-  } : {
-    network,
-    chainId: TEMPO_CHAIN_ID,
-    rpcUrl: "https://rpc.tempo.xyz",
-    defaultToken: TEMPO_USDC_MAINNET
-  };
-}
-function resolveTempoAsset(env = process.env, network = "mainnet") {
-  const address = env.DVM_TEMPO_CURRENCY ?? resolveTempoNetwork(network).defaultToken;
-  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) {
-  if (address.toLowerCase() === TEMPO_USDC_MAINNET.toLowerCase()) return "USDC.e";
-  if (address.toLowerCase() === TEMPO_PATH_USD_MODERATO.toLowerCase()) return "pathUSD";
-  return 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-GJ77YKVY.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(),
-    network: opts.network ?? "mainnet"
-  };
-  await opts.beforePersist?.(generated);
-  await updateConfig({
-    reason: "tempo_wallet_generate",
-    patch: () => ({
-      set: {
-        tempo: { method: "tempo", apiKey: privateKey, network: generated.network }
-      }
-    })
-  });
-  return generated;
-}
-async function getTempoUsdcBalance(account) {
-  const accountNetwork = account.network ?? "mainnet";
-  const network = resolveTempoNetwork(accountNetwork);
-  const tokenAddress = resolveTempoAsset(process.env, accountNetwork).address;
-  const { createPublicClient, http, erc20Abi } = await import("viem");
-  const { tempo, tempoModerato } = await import("viem/chains");
-  const chain = accountNetwork === "moderato" ? tempoModerato : tempo;
-  const { url: rpcUrl, source: rpcSource } = resolveRpcOverride(
-    process.env.DVM_TEMPO_RPC_URL,
-    network.rpcUrl
-  );
-  try {
-    const transportOptions = resolveRpcHttpTransportOptions(
-      rpcSource,
-      process.env.DVM_TEMPO_RPC_HEADERS_JSON
-    );
-    const client = createPublicClient({
-      chain,
-      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: network.chainId,
-      // 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)}`;
-}
-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,
-  TEMPO_MODERATO_CHAIN_ID,
-  TEMPO_PATH_USD_MODERATO,
-  TEMPO_MODERATO_RPC,
-  resolveTempoNetwork,
-  resolveTempoAsset,
-  tempoTokenLabel,
-  tempoTokenReference,
-  tempoBalanceCheckHint,
-  tryResolveTempoAsset,
-  tempoWrongAssetHint,
-  connectedTempoAccount,
-  generateTempoKey,
-  getTempoUsdcBalance,
-  deriveTempoAddress
-};