@tangle-network/tcloud 0.1.4 → 0.2.0

package/dist/chunk-KVXWEAK3.js

@@ -1,771 +0,0 @@
-// src/shielded.ts
-import { privateKeyToAccount } from "viem/accounts";
-import { keccak256, encodeAbiParameters, parseAbiParameters, concat, toBytes } from "viem";
-
-// src/client.ts
-var DEFAULT_BASE_URL = "https://router.tangle.tools/v1";
-async function proxiedFetch(privacy, url, init, streaming) {
-  if (!privacy || privacy.mode === "direct") {
-    return fetch(url, init);
-  }
-  if (privacy.mode === "relayer") {
-    if (!privacy.relayerUrl) {
-      throw new Error('relayerUrl is required when privacy mode is "relayer"');
-    }
-    const proxyPath = streaming ? "/relay/proxy-stream" : "/relay/proxy";
-    const hdrs = {};
-    if (init.headers) {
-      const entries = init.headers instanceof Headers ? Array.from(init.headers.entries()) : Object.entries(init.headers);
-      for (const [k, v] of entries) hdrs[k] = v;
-    }
-    return fetch(`${privacy.relayerUrl}${proxyPath}`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        target: url,
-        body: typeof init.body === "string" ? JSON.parse(init.body) : init.body,
-        headers: hdrs
-      })
-    });
-  }
-  if (privacy.mode === "socks5") {
-    if (!privacy.socksProxy) {
-      throw new Error('socksProxy is required when privacy mode is "socks5"');
-    }
-    const { SocksProxyAgent } = await import("socks-proxy-agent");
-    const agent = new SocksProxyAgent(privacy.socksProxy);
-    return fetch(url, {
-      ...init,
-      // @ts-expect-error agent is supported by Node's undici but not in the standard RequestInit type
-      agent
-    });
-  }
-  return fetch(url, init);
-}
-var TCloudClient = class {
-  baseURL;
-  apiKey;
-  model;
-  headers;
-  spendAuthFn;
-  privacy;
-  limits;
-  _totalSpent = 0;
-  _requestCount = 0;
-  constructor(config = {}) {
-    this.baseURL = (config.baseURL || DEFAULT_BASE_URL).replace(/\/$/, "");
-    this.apiKey = config.apiKey || process.env.TCLOUD_API_KEY || process.env.OPENAI_API_KEY;
-    this.model = config.model || "gpt-4o-mini";
-    this.privacy = config.privacy;
-    this.limits = config.limits;
-    this.headers = {
-      "Content-Type": "application/json",
-      "X-Tangle-Client": "tcloud-sdk/0.1.4"
-    };
-    if (this.apiKey) {
-      this.headers["Authorization"] = `Bearer ${this.apiKey}`;
-    }
-    if (config.routing?.mode) {
-      this.headers["X-Tangle-Routing"] = config.routing.mode;
-    }
-    if (config.routing?.prefer) {
-      this.headers["X-Tangle-Operator"] = config.routing.prefer;
-    }
-    if (config.routing?.blueprintId) {
-      this.headers["X-Tangle-Blueprint"] = config.routing.blueprintId;
-    }
-    if (config.routing?.serviceId) {
-      this.headers["X-Tangle-Service"] = config.routing.serviceId;
-    }
-    if (config.routing?.region) {
-      this.headers["X-Tangle-Region"] = config.routing.region;
-    }
-  }
-  /** Set the SpendAuth signer for private mode */
-  setSpendAuthSigner(fn) {
-    this.spendAuthFn = fn;
-  }
-  /** Current metering stats */
-  get usage() {
-    return {
-      totalSpent: this._totalSpent,
-      requestCount: this._requestCount,
-      limits: this.limits ? { ...this.limits } : void 0
-    };
-  }
-  /** Check spending limits before a request. Throws TCloudError if blocked. */
-  checkLimits() {
-    if (!this.limits) return;
-    if (this.limits.maxRequests && this._requestCount >= this.limits.maxRequests) {
-      this.limits.onLimitReached?.({ type: "requests", current: this._requestCount, limit: this.limits.maxRequests });
-      throw new TCloudError(429, `Request limit reached (${this._requestCount}/${this.limits.maxRequests})`);
-    }
-    if (this.limits.maxTotalSpend && this._totalSpent >= this.limits.maxTotalSpend) {
-      this.limits.onLimitReached?.({ type: "total", current: this._totalSpent, limit: this.limits.maxTotalSpend });
-      throw new TCloudError(429, `Spending limit reached ($${this._totalSpent.toFixed(6)}/$${this.limits.maxTotalSpend})`);
-    }
-    if (this.limits.maxRequests && this.limits.onLimitWarning) {
-      const pct = this._requestCount / this.limits.maxRequests;
-      if (pct >= 0.8) this.limits.onLimitWarning({ type: "requests", current: this._requestCount, limit: this.limits.maxRequests });
-    }
-    if (this.limits.maxTotalSpend && this.limits.onLimitWarning) {
-      const pct = this._totalSpent / this.limits.maxTotalSpend;
-      if (pct >= 0.8) this.limits.onLimitWarning({ type: "total", current: this._totalSpent, limit: this.limits.maxTotalSpend });
-    }
-  }
-  /** Track cost after a response, using actual pricing from response headers when available */
-  trackCost(completion, res) {
-    this._requestCount++;
-    if (completion.usage) {
-      let estimatedCost;
-      const inputPrice = res ? parseFloat(res.headers.get("x-tangle-price-input") || "0") : 0;
-      const outputPrice = res ? parseFloat(res.headers.get("x-tangle-price-output") || "0") : 0;
-      if (inputPrice > 0 || outputPrice > 0) {
-        estimatedCost = (completion.usage.prompt_tokens || 0) * inputPrice + (completion.usage.completion_tokens || 0) * outputPrice;
-      } else {
-        const tokens = completion.usage.total_tokens || 0;
-        estimatedCost = tokens * 1e-6;
-      }
-      this._totalSpent += estimatedCost;
-      if (this.limits?.maxCostPerRequest && estimatedCost > this.limits.maxCostPerRequest) {
-        this.limits.onLimitReached?.({ type: "cost", current: estimatedCost, limit: this.limits.maxCostPerRequest });
-      }
-    }
-  }
-  /** Chat completion (non-streaming) */
-  async chat(options) {
-    this.checkLimits();
-    const headers = { ...this.headers };
-    if (this.spendAuthFn) {
-      const auth = await this.spendAuthFn();
-      headers["X-Payment-Signature"] = JSON.stringify(auth);
-      delete headers["Authorization"];
-    }
-    const res = await proxiedFetch(this.privacy, `${this.baseURL}/chat/completions`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({
-        model: options.model || this.model,
-        messages: options.messages,
-        temperature: options.temperature,
-        max_tokens: options.maxTokens,
-        stream: false,
-        stop: options.stop,
-        top_p: options.topP,
-        frequency_penalty: options.frequencyPenalty,
-        presence_penalty: options.presencePenalty,
-        response_format: options.responseFormat,
-        tools: options.tools
-      })
-    }, false);
-    if (!res.ok) {
-      const err = await res.json().catch(() => ({ error: res.statusText }));
-      throw new TCloudError(res.status, err.error?.message || err.error || err.message || res.statusText);
-    }
-    const completion = await res.json();
-    this.trackCost(completion, res);
-    return completion;
-  }
-  /** Chat completion (streaming) — returns an async iterator of chunks */
-  async *chatStream(options) {
-    this.checkLimits();
-    const headers = { ...this.headers };
-    if (this.spendAuthFn) {
-      const auth = await this.spendAuthFn();
-      headers["X-Payment-Signature"] = JSON.stringify(auth);
-      delete headers["Authorization"];
-    }
-    const res = await proxiedFetch(this.privacy, `${this.baseURL}/chat/completions`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({
-        model: options.model || this.model,
-        messages: options.messages,
-        temperature: options.temperature,
-        max_tokens: options.maxTokens,
-        stream: true,
-        stop: options.stop,
-        top_p: options.topP
-      })
-    }, true);
-    if (!res.ok) {
-      const err = await res.json().catch(() => ({ error: res.statusText }));
-      throw new TCloudError(res.status, err.error || err.message || res.statusText);
-    }
-    const reader = res.body.getReader();
-    const decoder = new TextDecoder();
-    let buf = "";
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buf += decoder.decode(value, { stream: true });
-      const lines = buf.split("\n");
-      buf = lines.pop() || "";
-      for (const line of lines) {
-        if (!line.startsWith("data: ")) continue;
-        const data = line.slice(6).trim();
-        if (data === "[DONE]") {
-          this._requestCount++;
-          return;
-        }
-        try {
-          yield JSON.parse(data);
-        } catch {
-        }
-      }
-    }
-  }
-  /** Convenience: send a single message and get the text response */
-  async ask(message, modelOrOptions) {
-    const options = typeof modelOrOptions === "string" ? { model: modelOrOptions } : modelOrOptions;
-    const completion = await this.chat({
-      messages: [{ role: "user", content: message }],
-      ...options
-    });
-    return completion.choices[0]?.message?.content || "";
-  }
-  /** Convenience: send a single message and get the full completion (with usage) */
-  async askFull(message, modelOrOptions) {
-    const options = typeof modelOrOptions === "string" ? { model: modelOrOptions } : modelOrOptions;
-    return this.chat({
-      messages: [{ role: "user", content: message }],
-      ...options
-    });
-  }
-  /** Convenience: stream a single message and yield text chunks */
-  async *askStream(message, modelOrOptions) {
-    const options = typeof modelOrOptions === "string" ? { model: modelOrOptions } : modelOrOptions;
-    for await (const chunk of this.chatStream({
-      messages: [{ role: "user", content: message }],
-      ...options
-    })) {
-      const content = chunk.choices[0]?.delta?.content;
-      if (content) yield content;
-    }
-  }
-  /** List available models */
-  async models() {
-    const res = await proxiedFetch(this.privacy, `${this.baseURL}/models`, { headers: this.headers }, false);
-    if (!res.ok) throw new TCloudError(res.status, "Failed to fetch models");
-    const data = await res.json();
-    return data.data || [];
-  }
-  /** List active operators */
-  async operators() {
-    const apiRoot = this.baseURL.replace(/\/v1$/, "");
-    const res = await proxiedFetch(this.privacy, `${apiRoot}/api/operators`, { headers: this.headers }, false);
-    if (!res.ok) throw new TCloudError(res.status, "Failed to fetch operators");
-    return res.json();
-  }
-  /** Get credit balance */
-  async credits() {
-    const apiRoot = this.baseURL.replace(/\/v1$/, "");
-    const res = await proxiedFetch(this.privacy, `${apiRoot}/api/billing`, { headers: this.headers }, false);
-    if (!res.ok) throw new TCloudError(res.status, "Failed to fetch credits");
-    return res.json();
-  }
-  /** Add credits */
-  async addCredits(amount) {
-    const apiRoot = this.baseURL.replace(/\/v1$/, "");
-    const res = await proxiedFetch(this.privacy, `${apiRoot}/api/billing`, {
-      method: "POST",
-      headers: this.headers,
-      body: JSON.stringify({ amount })
-    }, false);
-    if (!res.ok) throw new TCloudError(res.status, "Failed to add credits");
-    return res.json();
-  }
-  /** Create a new API key */
-  async createKey(name) {
-    const apiRoot = this.baseURL.replace(/\/v1$/, "");
-    const res = await proxiedFetch(this.privacy, `${apiRoot}/api/keys`, {
-      method: "POST",
-      headers: this.headers,
-      body: JSON.stringify({ name })
-    }, false);
-    if (!res.ok) throw new TCloudError(res.status, "Failed to create API key");
-    return res.json();
-  }
-  /** List API keys */
-  async keys() {
-    const apiRoot = this.baseURL.replace(/\/v1$/, "");
-    const res = await proxiedFetch(this.privacy, `${apiRoot}/api/keys`, { headers: this.headers }, false);
-    if (!res.ok) throw new TCloudError(res.status, "Failed to fetch keys");
-    return res.json();
-  }
-  /** Revoke an API key */
-  async revokeKey(id) {
-    const apiRoot = this.baseURL.replace(/\/v1$/, "");
-    const res = await proxiedFetch(this.privacy, `${apiRoot}/api/keys/${id}`, {
-      method: "DELETE",
-      headers: this.headers
-    }, false);
-    if (!res.ok) throw new TCloudError(res.status, "Failed to revoke key");
-  }
-  /** Generate embeddings */
-  async embeddings(options) {
-    const res = await proxiedFetch(this.privacy, `${this.baseURL}/embeddings`, {
-      method: "POST",
-      headers: this.headers,
-      body: JSON.stringify({
-        model: options.model || "text-embedding-3-small",
-        input: options.input
-      })
-    }, false);
-    if (!res.ok) {
-      const err = await res.json().catch(() => ({ error: res.statusText }));
-      throw new TCloudError(res.status, err.error?.message || err.error || res.statusText);
-    }
-    this._requestCount++;
-    return res.json();
-  }
-  /** Generate images */
-  async imageGenerate(options) {
-    const res = await proxiedFetch(this.privacy, `${this.baseURL}/images/generations`, {
-      method: "POST",
-      headers: this.headers,
-      body: JSON.stringify({
-        model: options.model || "dall-e-3",
-        prompt: options.prompt,
-        n: options.n,
-        size: options.size,
-        quality: options.quality,
-        response_format: options.response_format
-      })
-    }, false);
-    if (!res.ok) {
-      const err = await res.json().catch(() => ({ error: res.statusText }));
-      throw new TCloudError(res.status, err.error?.message || err.error || res.statusText);
-    }
-    this._requestCount++;
-    return res.json();
-  }
-  /** Rerank documents by relevance to a query */
-  async rerank(options) {
-    const res = await proxiedFetch(this.privacy, `${this.baseURL}/rerank`, {
-      method: "POST",
-      headers: this.headers,
-      body: JSON.stringify({
-        model: options.model || "rerank-english-v3.0",
-        query: options.query,
-        documents: options.documents,
-        top_n: options.top_n
-      })
-    }, false);
-    if (!res.ok) {
-      const err = await res.json().catch(() => ({ error: res.statusText }));
-      throw new TCloudError(res.status, err.error?.message || err.error || res.statusText);
-    }
-    this._requestCount++;
-    return res.json();
-  }
-  /** Text-to-speech */
-  async speech(options) {
-    const res = await proxiedFetch(this.privacy, `${this.baseURL}/audio/speech`, {
-      method: "POST",
-      headers: this.headers,
-      body: JSON.stringify({
-        model: options.model || "tts-1",
-        input: options.input,
-        voice: options.voice || "alloy"
-      })
-    }, false);
-    if (!res.ok) {
-      const err = await res.json().catch(() => ({ error: res.statusText }));
-      throw new TCloudError(res.status, err.error?.message || err.error || res.statusText);
-    }
-    this._requestCount++;
-    return res.arrayBuffer();
-  }
-  /** Legacy completions endpoint */
-  async completions(options) {
-    const res = await proxiedFetch(this.privacy, `${this.baseURL}/completions`, {
-      method: "POST",
-      headers: this.headers,
-      body: JSON.stringify({
-        model: options.model || this.model,
-        prompt: options.prompt,
-        temperature: options.temperature,
-        max_tokens: options.maxTokens,
-        stop: options.stop,
-        top_p: options.topP
-      })
-    }, false);
-    if (!res.ok) {
-      const err = await res.json().catch(() => ({ error: res.statusText }));
-      throw new TCloudError(res.status, err.error?.message || err.error || res.statusText);
-    }
-    this._requestCount++;
-    return res.json();
-  }
-  /** Audio transcription (speech-to-text) */
-  async transcribe(file, options) {
-    const formData = new FormData();
-    formData.append("file", file, "audio.webm");
-    formData.append("model", options?.model || "whisper-1");
-    if (options?.language) formData.append("language", options.language);
-    if (options?.prompt) formData.append("prompt", options.prompt);
-    const headers = { ...this.headers };
-    delete headers["Content-Type"];
-    const res = await proxiedFetch(this.privacy, `${this.baseURL}/audio/transcriptions`, {
-      method: "POST",
-      headers,
-      body: formData
-    }, false);
-    if (!res.ok) {
-      const err = await res.json().catch(() => ({ error: res.statusText }));
-      throw new TCloudError(res.status, err.error?.message || err.error || res.statusText);
-    }
-    this._requestCount++;
-    return res.json();
-  }
-  /** Create a fine-tuning job */
-  async fineTuneCreate(options) {
-    const res = await proxiedFetch(this.privacy, `${this.baseURL}/fine_tuning/jobs`, {
-      method: "POST",
-      headers: this.headers,
-      body: JSON.stringify(options)
-    }, false);
-    if (!res.ok) {
-      const err = await res.json().catch(() => ({ error: res.statusText }));
-      throw new TCloudError(res.status, err.error?.message || err.error || res.statusText);
-    }
-    this._requestCount++;
-    return res.json();
-  }
-  /** List fine-tuning jobs */
-  async fineTuneList() {
-    const res = await proxiedFetch(this.privacy, `${this.baseURL}/fine_tuning/jobs`, {
-      headers: this.headers
-    }, false);
-    if (!res.ok) throw new TCloudError(res.status, "Failed to fetch fine-tuning jobs");
-    return res.json();
-  }
-  /** Submit a batch of chat requests */
-  async batch(requests) {
-    const res = await proxiedFetch(this.privacy, `${this.baseURL}/batch`, {
-      method: "POST",
-      headers: this.headers,
-      body: JSON.stringify({ requests })
-    }, false);
-    if (!res.ok) {
-      const err = await res.json().catch(() => ({ error: res.statusText }));
-      throw new TCloudError(res.status, err.error?.message || err.error || res.statusText);
-    }
-    return res.json();
-  }
-  /** Get batch job status */
-  async batchStatus(jobId) {
-    const res = await proxiedFetch(this.privacy, `${this.baseURL}/batch?id=${jobId}`, {
-      headers: this.headers
-    }, false);
-    if (!res.ok) throw new TCloudError(res.status, "Failed to fetch batch status");
-    return res.json();
-  }
-  /** Generate video */
-  async videoGenerate(options) {
-    const res = await proxiedFetch(this.privacy, `${this.baseURL}/video/generate`, {
-      method: "POST",
-      headers: this.headers,
-      body: JSON.stringify(options)
-    }, false);
-    if (!res.ok) {
-      const err = await res.json().catch(() => ({ error: res.statusText }));
-      throw new TCloudError(res.status, err.error?.message || err.error || res.statusText);
-    }
-    this._requestCount++;
-    return res.json();
-  }
-  /** Get video generation status */
-  async videoStatus(id) {
-    const res = await proxiedFetch(this.privacy, `${this.baseURL}/video?id=${id}`, {
-      headers: this.headers
-    }, false);
-    if (!res.ok) throw new TCloudError(res.status, "Failed to fetch video status");
-    return res.json();
-  }
-  /** Search models by name, provider, or capability */
-  async searchModels(query) {
-    const all = await this.models();
-    const q = query.toLowerCase();
-    return all.filter(
-      (m) => m.id.toLowerCase().includes(q) || m.name.toLowerCase().includes(q) || m._provider && m._provider.toLowerCase().includes(q)
-    );
-  }
-  /** Estimate cost for a request (without sending it) */
-  async estimateCost(options) {
-    const models = await this.models();
-    const model = models.find((m) => m.id === (options.model || this.model));
-    if (!model) return { inputCost: 0, outputCost: 0, total: 0 };
-    const inputCost = options.inputTokens * parseFloat(model.pricing.prompt);
-    const outputCost = options.outputTokens * parseFloat(model.pricing.completion);
-    return { inputCost, outputCost, total: inputCost + outputCost };
-  }
-};
-var TCloudError = class extends Error {
-  constructor(status, message) {
-    super(message);
-    this.status = status;
-    this.name = "TCloudError";
-  }
-};
-
-// src/shielded.ts
-var SPEND_TYPEHASH = keccak256(
-  toBytes(
-    "SpendAuthorization(bytes32 commitment,uint64 serviceId,uint8 jobIndex,uint256 amount,address operator,uint256 nonce,uint64 expiry)"
-  )
-);
-var DEFAULT_DOMAIN = {
-  name: "ShieldedCredits",
-  version: "1"
-};
-function generateWallet() {
-  const privateKeyBytes = crypto.getRandomValues(new Uint8Array(32));
-  const privateKey = "0x" + Array.from(privateKeyBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
-  const saltBytes = crypto.getRandomValues(new Uint8Array(32));
-  const salt = "0x" + Array.from(saltBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
-  const account = privateKeyToAccount(privateKey);
-  const commitment = keccak256(
-    encodeAbiParameters(
-      parseAbiParameters("address, bytes32"),
-      [account.address, salt]
-    )
-  );
-  return { privateKey, address: account.address, commitment, salt };
-}
-async function signSpendAuth(wallet, params) {
-  const account = privateKeyToAccount(wallet.privateKey);
-  const domainSeparator = keccak256(
-    encodeAbiParameters(
-      parseAbiParameters("bytes32, bytes32, bytes32, uint256, address"),
-      [
-        keccak256(toBytes("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")),
-        keccak256(toBytes(DEFAULT_DOMAIN.name)),
-        keccak256(toBytes(DEFAULT_DOMAIN.version)),
-        BigInt(params.chainId),
-        params.creditsAddress
-      ]
-    )
-  );
-  const structHash = keccak256(
-    encodeAbiParameters(
-      parseAbiParameters("bytes32, bytes32, uint64, uint8, uint256, address, uint256, uint64"),
-      [
-        SPEND_TYPEHASH,
-        wallet.commitment,
-        params.serviceId,
-        params.jobIndex,
-        params.amount,
-        params.operator,
-        params.nonce,
-        params.expiry
-      ]
-    )
-  );
-  const digest = keccak256(
-    concat([toBytes("0x1901"), toBytes(domainSeparator), toBytes(structHash)])
-  );
-  const signature = await account.sign({ hash: digest });
-  return {
-    commitment: wallet.commitment,
-    serviceId: params.serviceId.toString(),
-    jobIndex: params.jobIndex,
-    amount: params.amount.toString(),
-    operator: params.operator,
-    nonce: params.nonce.toString(),
-    expiry: params.expiry.toString(),
-    signature
-  };
-}
-function estimateCost(inputTokens, maxOutputTokens, inputPricePerM = 0.15, outputPricePerM = 0.6) {
-  const cost = inputTokens / 1e6 * inputPricePerM + maxOutputTokens / 1e6 * outputPricePerM;
-  return BigInt(Math.ceil(cost * 1e6));
-}
-function createShieldedClient(config = {}) {
-  const wallet = config.wallet || generateWallet();
-  const chainId = config.chainId || 3799;
-  const creditsAddress = config.creditsAddress || "0x0000000000000000000000000000000000000000";
-  const operatorAddress = config.operatorAddress || "0x0000000000000000000000000000000000000000";
-  const serviceId = config.serviceId || 1n;
-  let nonce = 0n;
-  const client = new TCloudClient({
-    ...config,
-    apiKey: void 0
-    // no API key in private mode
-  });
-  client.setSpendAuthSigner(async () => {
-    const currentNonce = nonce++;
-    const amount = estimateCost(500, 4096);
-    const buffered = amount + amount / 5n;
-    return signSpendAuth(wallet, {
-      serviceId,
-      jobIndex: 0,
-      amount: buffered,
-      operator: operatorAddress,
-      nonce: currentNonce,
-      expiry: BigInt(Math.floor(Date.now() / 1e3) + 300),
-      chainId,
-      creditsAddress
-    });
-  });
-  const monitor = { lastBalance: 0n, timer: null, replenishing: false };
-  if (config.autoReplenish) {
-    const ar = config.autoReplenish;
-    const intervalMs = ar.checkIntervalMs ?? 3e4;
-    const check = async () => {
-      try {
-        const balance = await fetchBalance(wallet.commitment, creditsAddress, chainId);
-        monitor.lastBalance = balance;
-        if (balance < ar.minBalance && !monitor.replenishing) {
-          monitor.replenishing = true;
-          try {
-            if (ar.fundingSource === "relayer") {
-              await replenishViaRelayer(ar.relayerUrl, wallet.commitment, wallet.privateKey);
-            } else {
-              await replenishDirect(
-                ar.fundingWalletKey,
-                ar.tokenAddress,
-                ar.replenishAmount,
-                wallet.commitment,
-                wallet.address,
-                creditsAddress,
-                chainId
-              );
-            }
-            monitor.lastBalance = await fetchBalance(wallet.commitment, creditsAddress, chainId);
-            console.log(`[tcloud/shielded] replenished. balance=${monitor.lastBalance}`);
-          } finally {
-            monitor.replenishing = false;
-          }
-        }
-      } catch (err) {
-        console.error("[tcloud/shielded] auto-replenish error:", err instanceof Error ? err.message : String(err));
-      }
-    };
-    void check();
-    monitor.timer = setInterval(() => void check(), intervalMs);
-  }
-  function stopAutoReplenish() {
-    if (monitor.timer) {
-      clearInterval(monitor.timer);
-      monitor.timer = null;
-    }
-  }
-  return Object.assign(client, { wallet, stopAutoReplenish });
-}
-var GET_ACCOUNT_ABI = [{
-  type: "function",
-  name: "getAccount",
-  inputs: [{ name: "commitment", type: "bytes32" }],
-  outputs: [{
-    name: "",
-    type: "tuple",
-    components: [
-      { name: "spendingKey", type: "address" },
-      { name: "token", type: "address" },
-      { name: "balance", type: "uint256" },
-      { name: "totalFunded", type: "uint256" },
-      { name: "totalSpent", type: "uint256" },
-      { name: "nonce", type: "uint256" }
-    ]
-  }],
-  stateMutability: "view"
-}];
-var FUND_CREDITS_ABI = [{
-  type: "function",
-  name: "fundCredits",
-  inputs: [
-    { name: "token", type: "address" },
-    { name: "amount", type: "uint256" },
-    { name: "commitment", type: "bytes32" },
-    { name: "spendingKey", type: "address" }
-  ],
-  outputs: [],
-  stateMutability: "nonpayable"
-}];
-var ERC20_APPROVE_ABI = [{
-  type: "function",
-  name: "approve",
-  inputs: [
-    { name: "spender", type: "address" },
-    { name: "amount", type: "uint256" }
-  ],
-  outputs: [{ name: "", type: "bool" }],
-  stateMutability: "nonpayable"
-}];
-function makeChain(chainId, rpcUrl) {
-  return {
-    id: chainId,
-    name: `chain-${chainId}`,
-    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
-    rpcUrls: { default: { http: [rpcUrl] } }
-  };
-}
-function getRpcUrl(chainId) {
-  if (chainId === 3799) return "https://testnet-rpc.tangle.tools";
-  if (chainId === 5845) return "https://rpc.tangle.tools";
-  return "http://localhost:8545";
-}
-async function fetchBalance(commitment, creditsAddress, chainId) {
-  const { createPublicClient, http } = await import("viem");
-  const rpcUrl = getRpcUrl(chainId);
-  const client = createPublicClient({ chain: makeChain(chainId, rpcUrl), transport: http(rpcUrl) });
-  const result = await client.readContract({
-    address: creditsAddress,
-    abi: GET_ACCOUNT_ABI,
-    functionName: "getAccount",
-    args: [commitment]
-  });
-  return result.balance;
-}
-async function replenishViaRelayer(relayerUrl, commitment, spendingKey) {
-  const res = await fetch(`${relayerUrl.replace(/\/$/, "")}/relay/fund-credits`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      anchorProof: { proof: "0x", auxPublicInputs: "0x", externalData: "0x", publicInputs: "0x", encryptions: "0x" },
-      commitment,
-      spendingKey
-    })
-  });
-  if (!res.ok) {
-    const body = await res.text();
-    throw new Error(`relayer fund-credits failed (${res.status}): ${body}`);
-  }
-}
-async function replenishDirect(fundingKey, tokenAddress, amount, commitment, spendingKeyAddress, creditsAddress, chainId) {
-  const { createPublicClient, createWalletClient, http } = await import("viem");
-  const { privateKeyToAccount: toAccount } = await import("viem/accounts");
-  const rpcUrl = getRpcUrl(chainId);
-  const chain = makeChain(chainId, rpcUrl);
-  const account = toAccount(fundingKey);
-  const pub = createPublicClient({ chain, transport: http(rpcUrl) });
-  const wal = createWalletClient({ account, chain, transport: http(rpcUrl) });
-  const approveHash = await wal.writeContract({
-    address: tokenAddress,
-    abi: ERC20_APPROVE_ABI,
-    functionName: "approve",
-    args: [creditsAddress, amount]
-  });
-  await pub.waitForTransactionReceipt({ hash: approveHash });
-  const fundHash = await wal.writeContract({
-    address: creditsAddress,
-    abi: FUND_CREDITS_ABI,
-    functionName: "fundCredits",
-    args: [tokenAddress, amount, commitment, spendingKeyAddress]
-  });
-  const receipt = await pub.waitForTransactionReceipt({ hash: fundHash });
-  if (receipt.status !== "success") {
-    throw new Error(`fundCredits reverted (tx: ${fundHash})`);
-  }
-}
-
-export {
-  TCloudClient,
-  TCloudError,
-  generateWallet,
-  signSpendAuth,
-  estimateCost,
-  createShieldedClient
-};