@envolvr/sdk 0.1.0

package/dist/cli.js

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+// envolvr: sign in, fund, run private inference, and verify its receipts.
+//
+//   ENVOLVR_PRIVATE_KEY  wallet key, for signin, deposit and testnet-mint
+//   ENVOLVR_API_KEY      API key, for everything else (or ~/.envolvr/credentials.json)
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { closeAccount, depositUsdg, getPricing, mintTestUsdg, signIn } from "./api.js";
+import { AUDIT_CHECKS, verifyGateway } from "./attest.js";
+import { Envolvr, savedReceipts, verifySaved } from "./client.js";
+import { fromMicros, TESTNET, toMicros } from "./network.js";
+import { privateKeySigner } from "./wallet.js";
+const HELP = `envolvr: private inference your agent can prove
+
+  envolvr signin [--save]             sign in with ENVOLVR_PRIVATE_KEY, print a new API key
+  envolvr testnet-mint <usd>          mint test USDG to the wallet (testnet)
+  envolvr deposit <usd> [--for 0x…]   deposit USDG (net of the deposit fee) to your balance
+  envolvr account                     balance and today's staking allowance
+  envolvr pricing                     the deposit fee and how token prices are set
+  envolvr models                      models and per-token prices
+  envolvr chat <prompt> [--model m] [--provider '{"only":["near-ai"]}']
+                                      one request; prints the reply and saves its receipt
+  envolvr verify [<receipt dir>|--last] [--accept-compose <hash>]
+                                      signature, billing, payer and on-chain anchor of a receipt
+  envolvr verify-gateway [--accept-compose <hash>]
+                                      attestation of the live gateway (TDX quote, source, TLS key)
+  envolvr close --yes [--refund-to 0x…]
+                                      close the account: revoke every API key and refund the
+                                      balance to the wallet (or the address given)
+
+Receipts are saved under ./envolvr-receipts (ENVOLVR_RECEIPTS to change).`;
+const args = process.argv.slice(2);
+const [command] = args;
+const flag = (name) => {
+    const i = args.indexOf(`--${name}`);
+    return i > 0 ? args[i + 1] : undefined;
+};
+const network = TESTNET;
+const receiptDir = process.env.ENVOLVR_RECEIPTS ?? 'envolvr-receipts';
+const credentialsPath = join(homedir(), '.envolvr', 'credentials.json');
+function wallet() {
+    const key = process.env.ENVOLVR_PRIVATE_KEY;
+    if (!key)
+        throw new Error('set ENVOLVR_PRIVATE_KEY to the wallet key');
+    return privateKeySigner(key, { rpcUrl: network.rpcUrl, chainId: network.chainId });
+}
+function apiKey() {
+    if (process.env.ENVOLVR_API_KEY)
+        return process.env.ENVOLVR_API_KEY;
+    if (existsSync(credentialsPath))
+        return JSON.parse(readFileSync(credentialsPath, 'utf8')).apiKey;
+    throw new Error('set ENVOLVR_API_KEY, or run envolvr signin --save');
+}
+const usd = (micros) => `$${fromMicros(micros)}`;
+const check = (ok) => (ok ? '✓' : ok === false ? '✗' : '·');
+async function main() {
+    switch (command) {
+        case 'signin': {
+            const { apiKey: key, wallet: w } = await signIn(wallet(), network);
+            if (args.includes('--save')) {
+                mkdirSync(join(homedir(), '.envolvr'), { recursive: true });
+                writeFileSync(credentialsPath, JSON.stringify({ apiKey: key, wallet: w }));
+                chmodSync(credentialsPath, 0o600);
+                console.log(`signed in as ${w}; API key saved to ${credentialsPath}`);
+            }
+            else {
+                console.log(`signed in as ${w}\nAPI key (shown once): ${key}`);
+            }
+            return;
+        }
+        case 'testnet-mint': {
+            const tx = await mintTestUsdg({ signer: wallet(), amountMicros: toMicros(args[1]), network });
+            console.log(`minted ${args[1]} test USDG: ${network.explorer}/tx/${tx}`);
+            return;
+        }
+        case 'deposit': {
+            const r = await depositUsdg({ signer: wallet(), amountMicros: toMicros(args[1]), account: flag('for'), network });
+            console.log(`deposited ${usd(r.amountMicros)} for ${r.account}: ${network.explorer}/tx/${r.depositTx}`);
+            console.log(`credit ${usd(r.expectedCreditMicros)} after the ${r.depositFeeBps / 100}% deposit fee, within seconds`);
+            return;
+        }
+        case 'account': {
+            const a = await new Envolvr({ apiKey: apiKey(), network }).account();
+            console.log(`${a.wallet}\nbalance ${usd(a.balanceMicros)} | allowance today ${usd(a.allowanceTodayMicros)}, left ${usd(a.allowanceLeftMicros)}`);
+            return;
+        }
+        case 'pricing': {
+            const p = await getPricing(network);
+            console.log(`tokens: ${p.tokenPricing}\ndeposit fee: ${p.depositFeeBps / 100}%`);
+            return;
+        }
+        case 'models':
+            console.log(JSON.stringify(await new Envolvr({ apiKey: apiKey(), network }).models(), null, 2));
+            return;
+        case 'chat': {
+            const client = new Envolvr({ apiKey: apiKey(), network, receiptDir });
+            const provider = flag('provider');
+            const { response, saved } = await client.chat({
+                model: flag('model') ?? 'z-ai/glm-5.3',
+                messages: [{ role: 'user', content: args[1] }],
+                ...(provider ? { provider: JSON.parse(provider) } : {}),
+            });
+            console.log(response.choices?.[0]?.message?.content ?? JSON.stringify(response));
+            console.log(`\ncost $${response.usage?.cost ?? '?'} | receipt ${saved?.id ?? 'none'}${saved?.dir ? ` saved to ${saved.dir}` : ''}`);
+            return;
+        }
+        case 'verify': {
+            const dir = args[1] && !args[1].startsWith('--') ? args[1] : savedReceipts(receiptDir).at(-1);
+            if (!dir)
+                throw new Error(`no saved receipt in ${receiptDir}`);
+            const key = process.env.ENVOLVR_API_KEY ?? (existsSync(credentialsPath) ? apiKey() : undefined);
+            const acceptCompose = flag('accept-compose') ? [flag('accept-compose')] : undefined;
+            const v = await verifySaved(dir, { network, apiKey: key, receiptDir, acceptCompose });
+            console.log(`receipt ${v.receiptId}`);
+            if (v.audit) {
+                for (const [id, label] of Object.entries(AUDIT_CHECKS)) {
+                    const c = v.audit.checks[id];
+                    console.log(`${c?.status === 'pass' ? '✓' : c?.status === 'fail' ? '✗' : '·'} ${label}`);
+                }
+                for (const c of v.audit.failed.filter((f) => !(f.id in AUDIT_CHECKS)))
+                    console.log(`✗ ${c.title}: ${c.detail}`);
+            }
+            else {
+                console.log(`${check(false)} signature                   ${String(v.signature.transcript)}`);
+            }
+            if (v.billing) {
+                console.log(`${check(true)} billing                     ${v.billing.cost} ${v.billing.currency} for ${v.billing.tokens.prompt}+${v.billing.tokens.completion} tokens, billed ${usd(BigInt(v.billing.billedMicroUsd))}`);
+                console.log(`${check(v.chargedToKey)} charged to this key         ${v.chargedToKey === undefined ? 'no API key given' : v.chargedToKey ? 'yes' : 'no'}`);
+            }
+            else {
+                console.log(`${check(undefined)} billing                     not priced (no billing event)`);
+            }
+            const a = v.anchor;
+            console.log(`${check(a.status === 'anchored')} anchor                      ${a.status === 'anchored'
+                ? `batch ${a.batchIndex}, leaf ${a.leafIndex} of ${a.count}, ${new Date(a.anchoredAt * 1000).toISOString()}, tx ${a.txHash}`
+                : a.status === 'pending' ? 'pending: batches close every 10 minutes (UTC)' : 'unknown to the proof service'}`);
+            const signed = v.audit?.signed ?? false;
+            const ok = signed && a.status === 'anchored';
+            console.log(`\nverdict: ${ok ? 'VERIFIED' : signed && a.status === 'pending' ? 'SIGNED, ANCHOR PENDING' : 'NOT VERIFIED'}`);
+            if (!signed && v.audit)
+                console.log('pap transcript:', JSON.stringify(v.signature.transcript, null, 2).slice(0, 4000));
+            process.exit(ok ? 0 : signed && a.status === 'pending' ? 2 : 1);
+        }
+        case 'close': {
+            if (!args.includes('--yes'))
+                throw new Error('closing revokes every API key of this wallet; run again with --yes');
+            const r = await closeAccount(wallet(), { refundTo: flag('refund-to'), network });
+            console.log(`account closed; ${r.revokedKeys} API key(s) revoked`);
+            console.log(r.refund
+                ? `refund #${r.refund.id}: ${usd(r.refund.amountMicros)} to ${r.refund.refundTo} (${r.refund.status === 'held' ? 'held for review' : 'paid from the credit vault shortly'})`
+                : 'no balance to refund');
+            return;
+        }
+        case 'verify-gateway': {
+            const r = await verifyGateway(network, { acceptCompose: flag('accept-compose') ? [flag('accept-compose')] : undefined });
+            console.log(typeof r.transcript === 'string' ? r.transcript : JSON.stringify(r.transcript, null, 2));
+            process.exit(r.verified ? 0 : 1);
+        }
+        default:
+            console.log(HELP);
+            process.exit(command && command !== 'help' && command !== '--help' ? 2 : 0);
+    }
+}
+main().catch((err) => {
+    const message = err.message;
+    console.error(message === 'fetch failed'
+        ? `error: could not reach envolvr (${network.gateway}, ${network.control}); try again shortly`
+        : `error: ${message}`);
+    process.exit(1);
+});

package/dist/client.d.ts

@@ -0,0 +1,84 @@
+import { type AuditSummary, type PapResult } from './attest.ts';
+import { type Network } from './network.ts';
+import { type Anchor, type Billing, type Receipt } from './receipts.ts';
+export interface SavedReceipt {
+    id: string;
+    receipt: Receipt;
+    /** Directory holding receipt.json, request.json, response.json. */
+    dir?: string;
+}
+export interface Verification {
+    receiptId: string;
+    /** pap's offline audit: attestation report, receipt signature, commitments, cited session. */
+    signature: PapResult | {
+        verified: false;
+        transcript: string;
+    };
+    /** The audit read check by check; undefined when it did not run. */
+    audit?: AuditSummary;
+    billing?: Billing;
+    /** Whether the receipt's payer commitment matches the API key given. */
+    chargedToKey?: boolean;
+    anchor: Anchor;
+}
+export declare class Envolvr {
+    readonly network: Network;
+    private apiKey;
+    private receiptDir;
+    constructor(opts: {
+        apiKey: string;
+        network?: Network;
+        receiptDir?: string;
+    });
+    /** Settings for the OpenAI SDK: `new OpenAI(envolvr.openai)`. Receipts are then yours to fetch. */
+    get openai(): {
+        baseURL: string;
+        apiKey: string;
+    };
+    account(): Promise<import("./api.ts").Account>;
+    pricing(): Promise<import("./api.ts").Pricing>;
+    /** GET /v1/models: every model with its per-token prices and routes. */
+    models(): Promise<unknown>;
+    /**
+     * A chat completion (non-streaming), with its receipt fetched and saved.
+     * `body` is an OpenAI chat completion request; add `provider: { only: [...] }`
+     * to pin providers.
+     */
+    chat(body: Record<string, unknown>): Promise<{
+        response: any;
+        receiptId: string | null;
+        saved?: SavedReceipt;
+    }>;
+    /**
+     * Fetch a receipt (within an hour of the response) and save it. With
+     * `receiptDir`, the request and response bytes and the signing keyset's
+     * attestation report are saved beside it.
+     */
+    receipt(id: string, bodies?: {
+        request?: string;
+        response?: string;
+    }): Promise<SavedReceipt>;
+    /** Keep the provider session the receipt cites (sessions, like receipts, expire). */
+    private saveSession;
+    /** Keep one attestation report per keyset, fetched while that keyset is live. */
+    private saveReport;
+    /**
+     * Verify a saved receipt: signature and commitments (pap, against the saved
+     * attestation report), what it billed and whether to this key, and its anchor
+     * on Robinhood Chain.
+     */
+    verify(dir: string, opts?: {
+        acceptCompose?: string[];
+    }): Promise<Verification>;
+}
+/** Verify a receipt saved by Envolvr.receipt (a directory with receipt.json). */
+export declare function verifySaved(dir: string, opts: {
+    network?: Network;
+    apiKey?: string;
+    receiptDir?: string;
+    acceptCompose?: string[];
+    /** Leave the signature to a separate `pap audit` run (for example where npx is unavailable). */
+    skipSignature?: boolean;
+}): Promise<Verification>;
+/** Saved receipt directories under `receiptDir`, oldest first. */
+export declare function savedReceipts(receiptDir: string): string[];

package/dist/client.js

@@ -0,0 +1,156 @@
+// The inference client. The gateway speaks the OpenAI API; this client adds
+// what an agent needs to keep the proof: every response's receipt is fetched
+// right away (the gateway keeps receipts for an hour) and saved with the exact
+// request and response bytes and the attestation report of the keyset that
+// signed it, so the receipt can be verified later, offline and on chain.
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getAccount, getPricing } from "./api.js";
+import { auditReceipt, fetchAttestationReport, summarizeAudit } from "./attest.js";
+import { TESTNET } from "./network.js";
+import { billingOf, chargedTo, verifyAnchor } from "./receipts.js";
+export class Envolvr {
+    network;
+    apiKey;
+    receiptDir;
+    constructor(opts) {
+        this.apiKey = opts.apiKey;
+        this.network = opts.network ?? TESTNET;
+        this.receiptDir = opts.receiptDir;
+    }
+    /** Settings for the OpenAI SDK: `new OpenAI(envolvr.openai)`. Receipts are then yours to fetch. */
+    get openai() {
+        return { baseURL: `${this.network.gateway}/v1`, apiKey: this.apiKey };
+    }
+    account() {
+        return getAccount(this.apiKey, this.network);
+    }
+    pricing() {
+        return getPricing(this.network);
+    }
+    /** GET /v1/models: every model with its per-token prices and routes. */
+    async models() {
+        const res = await fetch(`${this.network.gateway}/v1/models`, { headers: { authorization: `Bearer ${this.apiKey}` } });
+        if (!res.ok)
+            throw new Error(`/v1/models: HTTP ${res.status}`);
+        return res.json();
+    }
+    /**
+     * A chat completion (non-streaming), with its receipt fetched and saved.
+     * `body` is an OpenAI chat completion request; add `provider: { only: [...] }`
+     * to pin providers.
+     */
+    async chat(body) {
+        const request = JSON.stringify({ ...body, stream: false });
+        const res = await fetch(`${this.network.gateway}/v1/chat/completions`, {
+            method: 'POST', headers: { authorization: `Bearer ${this.apiKey}`, 'content-type': 'application/json' }, body: request,
+        });
+        const responseText = await res.text();
+        const receiptId = res.headers.get('x-receipt-id');
+        let response;
+        try {
+            response = JSON.parse(responseText);
+        }
+        catch {
+            response = responseText;
+        }
+        if (!res.ok) {
+            const message = typeof response === 'object' ? response?.error?.message : responseText;
+            throw Object.assign(new Error(`chat completion: HTTP ${res.status} ${message ?? ''}`.trim()), { status: res.status, receiptId });
+        }
+        const saved = receiptId ? await this.receipt(receiptId, { request, response: responseText }) : undefined;
+        return { response, receiptId, saved };
+    }
+    /**
+     * Fetch a receipt (within an hour of the response) and save it. With
+     * `receiptDir`, the request and response bytes and the signing keyset's
+     * attestation report are saved beside it.
+     */
+    async receipt(id, bodies = {}) {
+        const res = await fetch(`${this.network.gateway}/v1/aci/receipts/${encodeURIComponent(id)}`, {
+            headers: { authorization: `Bearer ${this.apiKey}` },
+        });
+        if (!res.ok)
+            throw new Error(`receipt ${id}: HTTP ${res.status}${res.status === 404 ? ' (receipts are kept for an hour)' : ''}`);
+        const raw = await res.text();
+        const receipt = JSON.parse(raw);
+        if (!this.receiptDir)
+            return { id, receipt };
+        const dir = join(this.receiptDir, id);
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, 'receipt.json'), raw);
+        if (bodies.request !== undefined)
+            writeFileSync(join(dir, 'request.json'), bodies.request);
+        if (bodies.response !== undefined)
+            writeFileSync(join(dir, 'response.json'), bodies.response);
+        await this.saveReport(String(receipt.workload_keyset_digest));
+        await this.saveSession(receipt, dir);
+        return { id, receipt, dir };
+    }
+    /** Keep the provider session the receipt cites (sessions, like receipts, expire). */
+    async saveSession(receipt, dir) {
+        const cited = receipt.event_log.find((e) => e.type === 'upstream.verified' && typeof e.session_id === 'string');
+        if (!cited)
+            return;
+        const res = await fetch(`${this.network.gateway}/v1/aci/sessions/${cited.session_id}`, {
+            headers: { authorization: `Bearer ${this.apiKey}` },
+        });
+        if (res.ok)
+            writeFileSync(join(dir, 'session.json'), await res.text());
+    }
+    /** Keep one attestation report per keyset, fetched while that keyset is live. */
+    async saveReport(keysetDigest) {
+        const reports = join(this.receiptDir, 'attestation');
+        const file = join(reports, `${keysetDigest.replace(':', '-')}.json`);
+        if (existsSync(file))
+            return;
+        const { nonce, report } = await fetchAttestationReport(this.network);
+        if (report.workload_keyset_digest !== keysetDigest)
+            return; // the gateway restarted since; nothing to pair with
+        mkdirSync(reports, { recursive: true });
+        writeFileSync(file, JSON.stringify(report));
+        writeFileSync(file.replace(/\.json$/, '.nonce'), nonce);
+    }
+    /**
+     * Verify a saved receipt: signature and commitments (pap, against the saved
+     * attestation report), what it billed and whether to this key, and its anchor
+     * on Robinhood Chain.
+     */
+    async verify(dir, opts = {}) {
+        return verifySaved(dir, { network: this.network, apiKey: this.apiKey, receiptDir: this.receiptDir, ...opts });
+    }
+}
+/** Verify a receipt saved by Envolvr.receipt (a directory with receipt.json). */
+export async function verifySaved(dir, opts) {
+    const network = opts.network ?? TESTNET;
+    const receiptPath = join(dir, 'receipt.json');
+    const receipt = JSON.parse(readFileSync(receiptPath, 'utf8'));
+    const reports = join(opts.receiptDir ?? join(dir, '..'), 'attestation');
+    const reportPath = join(reports, `${String(receipt.workload_keyset_digest).replace(':', '-')}.json`);
+    const signature = opts.skipSignature
+        ? { verified: false, transcript: 'skipped' }
+        : existsSync(reportPath)
+            ? await auditReceipt({
+                reportPath, receiptPath, acceptCompose: opts.acceptCompose,
+                nonce: existsSync(reportPath.replace(/\.json$/, '.nonce')) ? readFileSync(reportPath.replace(/\.json$/, '.nonce'), 'utf8') : undefined,
+                requestBodyPath: existsSync(join(dir, 'request.json')) ? join(dir, 'request.json') : undefined,
+                responseBodyPath: existsSync(join(dir, 'response.json')) ? join(dir, 'response.json') : undefined,
+                sessionPath: existsSync(join(dir, 'session.json')) ? join(dir, 'session.json') : undefined,
+            })
+            : { verified: false, transcript: `no attestation report for keyset ${String(receipt.workload_keyset_digest)} in ${reports}` };
+    return {
+        receiptId: receipt.receipt_id,
+        signature,
+        audit: typeof signature.transcript === 'object' ? summarizeAudit(signature) : undefined,
+        billing: billingOf(receipt),
+        chargedToKey: opts.apiKey ? chargedTo(receipt, opts.apiKey) : undefined,
+        anchor: await verifyAnchor(receipt, network),
+    };
+}
+/** Saved receipt directories under `receiptDir`, oldest first. */
+export function savedReceipts(receiptDir) {
+    if (!existsSync(receiptDir))
+        return [];
+    return readdirSync(receiptDir).filter((d) => d !== 'attestation' && existsSync(join(receiptDir, d, 'receipt.json')))
+        .map((d) => join(receiptDir, d)).sort();
+}

package/dist/evm.d.ts

@@ -0,0 +1,41 @@
+export type Hex = `0x${string}`;
+export declare const hex: (b: Uint8Array) => Hex;
+export declare function unhex(h: string): Uint8Array;
+/** Minimal big-endian bytes of a non-negative integer; zero is empty. */
+export declare function uintBytes(n: bigint): Uint8Array;
+type RlpItem = Uint8Array | RlpItem[];
+export declare function rlp(item: RlpItem): Uint8Array;
+/** EIP-191 personal_sign: a 65-byte signature as 0x hex (v = 27 or 28). */
+export declare function personalSign(message: string, privateKey: Uint8Array): string;
+export declare function addressOfKey(privateKey: Uint8Array): string;
+export interface Tx {
+    chainId: bigint;
+    nonce: bigint;
+    maxPriorityFeePerGas: bigint;
+    maxFeePerGas: bigint;
+    gas: bigint;
+    to: string;
+    value: bigint;
+    data: string;
+}
+/** Sign an EIP-1559 (type 2) transaction. Returns the raw bytes and the hash. */
+export declare function signTx(tx: Tx, privateKey: Uint8Array): {
+    raw: Hex;
+    hash: Hex;
+};
+export declare function selector(signature: string): string;
+/** ABI-encode a call whose arguments are all static words (bytes32, uintN, address). */
+export declare function encodeCall(signature: string, args: (bigint | string)[]): Hex;
+/** The 32-byte words of an ABI return value. */
+export declare function decodeWords(data: string): string[];
+export declare class RpcError extends Error {
+    readonly data: string | undefined;
+    constructor(message: string, data?: string);
+}
+export declare class Rpc {
+    private url;
+    private timeoutMs;
+    constructor(url: string, timeoutMs?: number);
+    call<T>(method: string, params: unknown[]): Promise<T>;
+}
+export {};

package/dist/evm.js

@@ -0,0 +1,102 @@
+// Minimal EVM client: JSON-RPC, RLP, EIP-1559 transactions signed with a
+// secp256k1 key, EIP-191 personal_sign, and ABI encoding of static arguments.
+// No dependencies beyond @noble. The same encoders as the control plane
+// (control/src/evm.ts), pinned to Foundry's cast in the tests.
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { keccak_256 } from '@noble/hashes/sha3';
+import { bytesToHex, concatBytes, hexToBytes, utf8ToBytes } from '@noble/hashes/utils';
+export const hex = (b) => `0x${bytesToHex(b)}`;
+export function unhex(h) {
+    const s = h.replace(/^0x/, '');
+    return hexToBytes(s.length % 2 ? `0${s}` : s);
+}
+/** Minimal big-endian bytes of a non-negative integer; zero is empty. */
+export function uintBytes(n) {
+    if (n < 0n)
+        throw new Error('negative integer');
+    if (n === 0n)
+        return new Uint8Array();
+    const h = n.toString(16);
+    return hexToBytes(h.length % 2 ? `0${h}` : h);
+}
+export function rlp(item) {
+    const length = (len, offset) => {
+        if (len < 56)
+            return Uint8Array.of(offset + len);
+        const l = uintBytes(BigInt(len));
+        return concatBytes(Uint8Array.of(offset + 55 + l.length), l);
+    };
+    if (item instanceof Uint8Array) {
+        if (item.length === 1 && item[0] < 0x80)
+            return item;
+        return concatBytes(length(item.length, 0x80), item);
+    }
+    const body = concatBytes(...item.map(rlp));
+    return concatBytes(length(body.length, 0xc0), body);
+}
+/** EIP-191 personal_sign: a 65-byte signature as 0x hex (v = 27 or 28). */
+export function personalSign(message, privateKey) {
+    const bytes = utf8ToBytes(message);
+    const digest = keccak_256(concatBytes(utf8ToBytes(`\x19Ethereum Signed Message:\n${bytes.length}`), bytes));
+    const sig = secp256k1.sign(digest, privateKey);
+    return `0x${bytesToHex(sig.toCompactRawBytes())}${(27 + sig.recovery).toString(16)}`;
+}
+export function addressOfKey(privateKey) {
+    const pub = secp256k1.getPublicKey(privateKey, false);
+    return hex(keccak_256(pub.slice(1)).slice(-20));
+}
+/** Sign an EIP-1559 (type 2) transaction. Returns the raw bytes and the hash. */
+export function signTx(tx, privateKey) {
+    const fields = [
+        uintBytes(tx.chainId), uintBytes(tx.nonce), uintBytes(tx.maxPriorityFeePerGas), uintBytes(tx.maxFeePerGas),
+        uintBytes(tx.gas), unhex(tx.to), uintBytes(tx.value), unhex(tx.data), [],
+    ];
+    const digest = keccak_256(concatBytes(Uint8Array.of(2), rlp(fields)));
+    const sig = secp256k1.sign(digest, privateKey);
+    const raw = concatBytes(Uint8Array.of(2), rlp([...fields, uintBytes(BigInt(sig.recovery)), uintBytes(sig.r), uintBytes(sig.s)]));
+    return { raw: hex(raw), hash: hex(keccak_256(raw)) };
+}
+export function selector(signature) {
+    return bytesToHex(keccak_256(utf8ToBytes(signature)).slice(0, 4));
+}
+/** ABI-encode a call whose arguments are all static words (bytes32, uintN, address). */
+export function encodeCall(signature, args) {
+    const words = args.map((a) => (typeof a === 'bigint' ? a.toString(16) : a.replace(/^0x/, '').toLowerCase()).padStart(64, '0'));
+    if (words.some((w) => w.length !== 64 || !/^[0-9a-f]+$/.test(w)))
+        throw new Error(`bad argument for ${signature}`);
+    return `0x${selector(signature)}${words.join('')}`;
+}
+/** The 32-byte words of an ABI return value. */
+export function decodeWords(data) {
+    const h = data.replace(/^0x/, '');
+    return Array.from({ length: Math.floor(h.length / 64) }, (_, i) => `0x${h.slice(i * 64, i * 64 + 64)}`);
+}
+export class RpcError extends Error {
+    data;
+    constructor(message, data) {
+        super(message);
+        this.data = data;
+    }
+}
+export class Rpc {
+    url;
+    timeoutMs;
+    constructor(url, timeoutMs = 20_000) {
+        this.url = url;
+        this.timeoutMs = timeoutMs;
+    }
+    async call(method, params) {
+        const res = await fetch(this.url, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ jsonrpc: '2.0', id: 1, method, params }),
+            signal: AbortSignal.timeout(this.timeoutMs),
+        });
+        const body = (await res.json());
+        if (body.error)
+            throw new RpcError(`${method}: ${body.error.message}`, body.error.data);
+        if (!res.ok || !('result' in body))
+            throw new RpcError(`${method} failed: HTTP ${res.status}`);
+        return body.result;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { closeAccount, closeAccountMessage, depositUsdg, getAccount, getPricing, mintTestUsdg, netCredit, signIn, signInMessage, } from './api.ts';
+export type { Account, Pricing } from './api.ts';
+export { auditReceipt, fetchAttestationReport, runPap, verifyGateway } from './attest.ts';
+export type { PapResult } from './attest.ts';
+export { Envolvr, savedReceipts, verifySaved } from './client.ts';
+export type { SavedReceipt, Verification } from './client.ts';
+export { fromMicros, TESTNET, toMicros } from './network.ts';
+export type { Network } from './network.ts';
+export { billingOf, chargedTo, payerCommitment, proofLeadsToRoot, receiptDigest, verifyAnchor } from './receipts.ts';
+export type { Anchor, Billing, Receipt } from './receipts.ts';
+export { privateKeySigner } from './wallet.ts';
+export type { Signer } from './wallet.ts';

package/dist/index.js

@@ -0,0 +1,7 @@
+// @envolvr/sdk: private, verifiable inference for agents on Robinhood Chain.
+export { closeAccount, closeAccountMessage, depositUsdg, getAccount, getPricing, mintTestUsdg, netCredit, signIn, signInMessage, } from "./api.js";
+export { auditReceipt, fetchAttestationReport, runPap, verifyGateway } from "./attest.js";
+export { Envolvr, savedReceipts, verifySaved } from "./client.js";
+export { fromMicros, TESTNET, toMicros } from "./network.js";
+export { billingOf, chargedTo, payerCommitment, proofLeadsToRoot, receiptDigest, verifyAnchor } from "./receipts.js";
+export { privateKeySigner } from "./wallet.js";

package/dist/network.d.ts

@@ -0,0 +1,19 @@
+export interface Network {
+    /** OpenAI-compatible inference gateway (attested TDX VM). */
+    gateway: string;
+    /** Sign-in, account, pricing and receipt proofs. */
+    control: string;
+    chainId: number;
+    rpcUrl: string;
+    explorer: string;
+    /** USDG token (a test stand-in on testnet, with an open mint). */
+    usdg: string;
+    creditVault: string;
+    receiptAnchor: string;
+    /** This gateway's log in ReceiptAnchor: keccak256("envolvr.provider:<dstack app id>"). */
+    providerId: string;
+}
+export declare const TESTNET: Network;
+/** USDG and envolvr balances have 6 decimals: "1.5" -> 1500000n. */
+export declare function toMicros(amount: string | number): bigint;
+export declare function fromMicros(micros: bigint | string): string;

package/dist/network.js

@@ -0,0 +1,27 @@
+// Where envolvr runs. Robinhood Chain testnet until mainnet.
+export const TESTNET = {
+    gateway: 'https://api.envolvr.xyz',
+    control: 'https://auth.envolvr.xyz',
+    chainId: 46630,
+    rpcUrl: 'https://rpc.testnet.chain.robinhood.com/rpc',
+    explorer: 'https://explorer.testnet.chain.robinhood.com',
+    usdg: '0xF7326a325aED45a1BF5D1268982f519BeCe941b6',
+    creditVault: '0x2aaB804f3eB6B436CB542d56D171d020bC2d7c51',
+    receiptAnchor: '0xff179938C830134D8E2922dAe7e16Ee4F0E33853',
+    providerId: '0x86b99987cd8f8ebddc2dd0efa61ed52b5db594430f12446db424da0d9c4b831f',
+};
+/** USDG and envolvr balances have 6 decimals: "1.5" -> 1500000n. */
+export function toMicros(amount) {
+    const s = String(amount).trim();
+    const m = /^(\d+)(?:\.(\d{0,6}))?$/.exec(s);
+    if (!m)
+        throw new Error(`not a USD amount with at most 6 decimals: ${s}`);
+    return BigInt(m[1]) * 1000000n + BigInt((m[2] ?? '').padEnd(6, '0'));
+}
+export function fromMicros(micros) {
+    const v = BigInt(micros);
+    const sign = v < 0n ? '-' : '';
+    const a = v < 0n ? -v : v;
+    const frac = (a % 1000000n).toString().padStart(6, '0').replace(/0+$/, '');
+    return `${sign}${a / 1000000n}${frac ? `.${frac}` : ''}`;
+}