@goassay-ai/sdk 0.0.0-stage → 0.1.0

package/dist/rest.js

@@ -0,0 +1,43 @@
+import { isObject } from "./core/meta.js";
+import { ServerError } from "./errors.js";
+import { restError } from "./mcp.js";
+/** The REST API (spec section 2.2): `{data}` on success, a typed error from `{error}` otherwise. */
+export class RestClient {
+    http;
+    base;
+    now;
+    constructor(http, base, now = Date.now) {
+        this.http = http;
+        this.base = base;
+        this.now = now;
+    }
+    /** GETs are retried; POSTs are not (a challenge or a bind is not resent blindly). */
+    async get(path) {
+        return this.#send("GET", path, undefined);
+    }
+    async post(path, body) {
+        return this.#send("POST", path, body);
+    }
+    async #send(method, path, body) {
+        const res = await this.http.request({
+            url: `${this.base}${path}`,
+            method,
+            ...(body !== undefined ? { headers: { "content-type": "application/json" }, body: JSON.stringify(body) } : {}),
+            retry: method === "GET",
+        });
+        if (res.status < 200 || res.status > 299) {
+            throw (restError(res.status, res.text, res.headers.get("retry-after"), this.now()) ??
+                new ServerError(`HTTP_${res.status}`, `Assay answered HTTP ${res.status}`, { status: res.status }));
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(res.text);
+        }
+        catch {
+            parsed = undefined;
+        }
+        if (!isObject(parsed) || !("data" in parsed))
+            throw new ServerError("API_BAD_ANSWER", "Assay sent an answer the SDK cannot read", { status: res.status });
+        return { data: parsed.data, date: res.headers.get("date") };
+    }
+}

package/dist/schemes/eip155/bind.d.ts

@@ -0,0 +1,17 @@
+import type { RestClient } from "../../rest.js";
+import type { EvmSigner } from "../../signer.js";
+/** The `data` of `POST /agents/me/delegate`; `status` is `ACTIVE` or `PENDING_APPROVAL`. */
+export type BindAnswer = Record<string, unknown>;
+/**
+ * Binds an EVM key to the API key's credential (spec section 5): the challenge, its field-by-field
+ * check, the signature over typed data rebuilt from the SDK's own constants, the bind request, and
+ * a check that the answer names this key (as `delegate` when `ACTIVE`, as `pendingDelegate` when
+ * `PENDING_APPROVAL`). A challenge refused only on its expiry is retried once.
+ */
+export declare function bindEvmKey(o: {
+    signer: EvmSigner;
+    chainId: number;
+    credentialId: string;
+    api: RestClient;
+    now: () => number;
+}): Promise<BindAnswer>;

package/dist/schemes/eip155/bind.js

@@ -0,0 +1,59 @@
+import { checkBindingChallenge } from "../../core/binding.js";
+import { parseCaip10 } from "../../core/caip.js";
+import { correctedNow, dateHeaderOffset } from "../../core/clock.js";
+import { SignerRefusal } from "../../core/errors.js";
+import { getAddress } from "../../core/hex.js";
+import { isObject } from "../../core/meta.js";
+import { PaymentError } from "../../errors.js";
+/**
+ * Binds an EVM key to the API key's credential (spec section 5): the challenge, its field-by-field
+ * check, the signature over typed data rebuilt from the SDK's own constants, the bind request, and
+ * a check that the answer names this key (as `delegate` when `ACTIVE`, as `pendingDelegate` when
+ * `PENDING_APPROVAL`). A challenge refused only on its expiry is retried once.
+ */
+export async function bindEvmKey(o) {
+    const address = getAddress(o.signer.address);
+    for (let attempt = 0; attempt < 2; attempt++) {
+        const challenge = await o.api.post("/agents/me/delegate/challenge", { delegate: address });
+        const local = o.now() / 1000;
+        const nowSeconds = correctedNow(local, dateHeaderOffset(challenge.date, local));
+        let typedData;
+        try {
+            typedData = checkBindingChallenge(challenge.data, {
+                localAddress: address,
+                credentialId: o.credentialId,
+                chainId: o.chainId,
+                nowSeconds,
+            });
+        }
+        catch (err) {
+            if (!(err instanceof SignerRefusal))
+                throw err;
+            if (err.field === "message.expiresAt") {
+                if (attempt === 0)
+                    continue;
+                throw new PaymentError("BINDING_CLOCK", "the binding challenge expired twice; check this machine's clock");
+            }
+            throw new PaymentError("BINDING_CHALLENGE_REFUSED", `the binding challenge failed its check (${err.field}); nothing was signed`, { details: { field: err.field } });
+        }
+        const challengeId = challenge.data.challengeId;
+        const signature = await o.signer.signTypedData(typedData);
+        if (typeof signature !== "string" || !/^0x[0-9a-fA-F]{130}$/.test(signature)) {
+            throw new PaymentError("SIGNER_FAILED", "the signer did not return a 65-byte signature");
+        }
+        const bound = await o.api.post("/agents/me/delegate", { challengeId, signature });
+        const data = isObject(bound.data) ? bound.data : {};
+        const names = (v) => {
+            const p = typeof v === "string" ? parseCaip10(v) : null;
+            return p !== null && p.chainId === o.chainId && p.address === address;
+        };
+        // ACTIVE: this key is the delegate now. PENDING_APPROVAL: another key stays bound and keeps
+        // signing; this one waits as `pendingDelegate` until a person approves it.
+        const accepted = (data.status === "ACTIVE" && names(data.delegate)) ||
+            (data.status === "PENDING_APPROVAL" && names(data.pendingDelegate));
+        if (!accepted)
+            throw new PaymentError("BINDING_NOT_ACCEPTED", "Assay did not confirm the binding of this key");
+        return data;
+    }
+    throw new PaymentError("BINDING_CLOCK", "the binding challenge expired twice; check this machine's clock");
+}

package/dist/schemes/eip155/index.d.ts

@@ -0,0 +1,71 @@
+import { ChainReader } from "../../core/chain.js";
+import type { GuardContext, GuardResult } from "../../core/guard-types.js";
+import { type Address } from "../../core/hex.js";
+import { type VoucherTypedData, type WireVoucher } from "../../core/voucher.js";
+import type { PaymentScheme, Prepared, PrepareInput } from "../types.js";
+/** One EVM network: built into the SDK, or configured by the caller. */
+export interface Eip155Network {
+    /** The chain id; when given it must be the one in the CAIP-2 key. */
+    chainId?: number;
+    /** CAIP-10 of the escrow (the EIP-712 `verifyingContract`). */
+    escrow: string;
+    /** CAIP-19 erc20 asset. */
+    asset: string;
+    decimals: number;
+    /** JSON-RPC URLs for the chain reads of G4/G6. Every one must agree. */
+    rpcUrls: string[];
+}
+export interface NetworkEntry {
+    id: string;
+    chainId: number;
+    escrow: Address;
+    escrowCaip10: string;
+    asset: string;
+    decimals: number;
+    rpc: readonly string[];
+}
+/** Local limits in dollars, as decimal strings (G7). */
+export interface Limits {
+    maxPerCall: string;
+    maxPerDay: string;
+}
+export declare const DEFAULT_LIMITS: Readonly<Limits>;
+/**
+ * Checks and freezes a network table. `fail` makes the error: a `ConfigError` for the caller's
+ * own table, a server error for one the API sent. Non-eip155 entries are skipped.
+ */
+export declare function eip155Networks(table: Record<string, Eip155Network>, fail?: (message: string) => Error): Map<string, NetworkEntry>;
+export declare function checkLimits(limits: Limits): Limits;
+export type GuardedVoucher = {
+    ok: true;
+    wire: WireVoucher;
+    typedData: VoucherTypedData;
+};
+/**
+ * The one path from a requirement to a voucher: the guards and the builder see the same frozen
+ * copy, and the network the guards check is the caller's own entry for `requirement.network`.
+ * Returns the first refusal, or the voucher to sign.
+ */
+export declare function guardAndBuild(ctx: Omit<GuardContext, "network">, issuedAt: number, networks: ReadonlyMap<string, NetworkEntry>): GuardedVoucher | Exclude<GuardResult, {
+    ok: true;
+}>;
+/** Tests only: forget every signed voucher of this process. */
+export declare function resetSpendLedger(): void;
+export interface Eip155SchemeOptions {
+    /** The network table: built into the SDK, or the caller's for non-production environments. */
+    networks: ReadonlyMap<string, NetworkEntry>;
+    limits: Limits;
+    chain: ChainReader;
+    /** Milliseconds clock. */
+    now: () => number;
+    /** Server minus local clock, seconds (spec section 7). */
+    dateOffset: () => number;
+}
+export declare class Eip155Scheme implements PaymentScheme {
+    #private;
+    private readonly o;
+    readonly namespace = "eip155";
+    constructor(o: Eip155SchemeOptions);
+    prepare(input: PrepareInput): Promise<Prepared>;
+    onRefused(code: string, input: PrepareInput): Promise<void>;
+}

package/dist/schemes/eip155/index.js

@@ -0,0 +1,264 @@
+/**
+ * The `eip155` payment scheme: EIP-712 vouchers and the EIP-712 key binding, behind the
+ * {@link PaymentScheme} interface. Guards G1-G12 run on one frozen copy of the requirement, the
+ * voucher is built from that same copy and the caller's own network entry, and only then signed.
+ */
+import { eip155ChainId, parseCaip10, parseCaip19Erc20 } from "../../core/caip.js";
+import { ChainReader, isUsableRpcUrl } from "../../core/chain.js";
+import { correctedNow } from "../../core/clock.js";
+import { SignerRefusal } from "../../core/errors.js";
+import { checkAll, usdToAtomic } from "../../core/guards.js";
+import { getAddress } from "../../core/hex.js";
+import { isObject, voucherEnvelope } from "../../core/meta.js";
+import { buildVoucher } from "../../core/voucher.js";
+import { ConfigError } from "../../errors.js";
+export const DEFAULT_LIMITS = Object.freeze({ maxPerCall: "0.50", maxPerDay: "5" });
+/**
+ * Checks and freezes a network table. `fail` makes the error: a `ConfigError` for the caller's
+ * own table, a server error for one the API sent. Non-eip155 entries are skipped.
+ */
+export function eip155Networks(table, fail = (m) => new ConfigError(m)) {
+    const out = new Map();
+    for (const [id, n] of Object.entries(table)) {
+        if (!id.startsWith("eip155:"))
+            continue;
+        const chainId = eip155ChainId(id);
+        const escrow = typeof n?.escrow === "string" ? parseCaip10(n.escrow) : null;
+        const asset = typeof n?.asset === "string" ? parseCaip19Erc20(n.asset) : null;
+        if (chainId === null)
+            throw fail(`networks: ${id} is not a CAIP-2 eip155 chain`);
+        if (n?.chainId !== undefined && n.chainId !== chainId)
+            throw fail(`networks.${id}.chainId is not ${chainId}`);
+        if (!escrow || escrow.chainId !== chainId)
+            throw fail(`networks.${id}.escrow must be a checksummed CAIP-10 account on ${id}`);
+        if (!asset || asset.chainId !== chainId)
+            throw fail(`networks.${id}.asset must be a checksummed CAIP-19 erc20 asset on ${id}`);
+        if (!Number.isInteger(n.decimals) || n.decimals < 0 || n.decimals > 36)
+            throw fail(`networks.${id}.decimals is invalid`);
+        const rpc = n.rpcUrls;
+        if (!Array.isArray(rpc) || rpc.length === 0 || !rpc.every((u) => typeof u === "string" && isUsableRpcUrl(u))) {
+            throw fail(`networks.${id}.rpcUrls must list at least one https RPC URL`);
+        }
+        out.set(id, Object.freeze({
+            id,
+            chainId,
+            escrow: escrow.address,
+            escrowCaip10: n.escrow,
+            asset: n.asset,
+            decimals: n.decimals,
+            rpc: Object.freeze([...rpc]),
+        }));
+    }
+    return out;
+}
+export function checkLimits(limits) {
+    const perCall = typeof limits?.maxPerCall === "string" ? usdToAtomic(limits.maxPerCall, 6) : null;
+    const perDay = typeof limits?.maxPerDay === "string" ? usdToAtomic(limits.maxPerDay, 6) : null;
+    if (perCall === null || perCall === 0n)
+        throw new ConfigError('limits.maxPerCall must be a positive dollar amount such as "0.50"');
+    if (perDay === null || perDay === 0n)
+        throw new ConfigError('limits.maxPerDay must be a positive dollar amount such as "5"');
+    if (perCall > perDay)
+        throw new ConfigError("limits.maxPerCall must not be above limits.maxPerDay");
+    return Object.freeze({ maxPerCall: limits.maxPerCall, maxPerDay: limits.maxPerDay });
+}
+function deepFreeze(value) {
+    if (typeof value === "object" && value !== null) {
+        for (const v of Object.values(value))
+            deepFreeze(v);
+        Object.freeze(value);
+    }
+    return value;
+}
+/**
+ * The one path from a requirement to a voucher: the guards and the builder see the same frozen
+ * copy, and the network the guards check is the caller's own entry for `requirement.network`.
+ * Returns the first refusal, or the voucher to sign.
+ */
+export function guardAndBuild(ctx, issuedAt, networks) {
+    let requirement;
+    try {
+        requirement = deepFreeze(structuredClone(ctx.requirement));
+    }
+    catch {
+        return { ok: false, guard: "G1", code: "G1_NOT_A_REQUIREMENT", reason: "the payment request could not be copied" };
+    }
+    const id = isObject(requirement) && typeof requirement.network === "string" ? requirement.network : null;
+    const entry = id !== null ? networks.get(id) : undefined;
+    const network = entry
+        ? { id: entry.id, escrow: entry.escrowCaip10, asset: entry.asset, decimals: entry.decimals }
+        : null;
+    const result = checkAll({ ...ctx, requirement, network });
+    if (!result.ok)
+        return result;
+    const req = requirement;
+    try {
+        const built = buildVoucher(req, issuedAt, {
+            caip2: entry.id,
+            escrow: entry.escrowCaip10,
+            asset: entry.asset,
+            decimals: entry.decimals,
+        });
+        const m = built.typedData.message;
+        const same = m.amount === BigInt(req.amount.amount) &&
+            m.seq === BigInt(req.seq) &&
+            m.payer === getAddress(parseCaip10(req.payer).address) &&
+            m.provider === getAddress(parseCaip10(req.provider).address) &&
+            built.typedData.domain.verifyingContract === entry.escrow &&
+            built.typedData.domain.chainId === entry.chainId;
+        if (!same)
+            return {
+                ok: false,
+                guard: "G1",
+                code: "G1_NOT_A_REQUIREMENT",
+                reason: "the voucher differs from the checked requirement",
+            };
+        return { ok: true, ...built };
+    }
+    catch (err) {
+        if (err instanceof SignerRefusal)
+            return { ok: false, guard: "G1", code: "G1_NOT_A_REQUIREMENT", reason: err.message };
+        throw err;
+    }
+}
+const SPEND_WINDOW_SECONDS = 86_400;
+/**
+ * Vouchers signed in this process, by key: every client using one key shares one 24 h cap. One
+ * array per key, only ever changed in place, so a reservation is always released from the list
+ * the guards read. Per process only: not shared across worker threads or restarts; the
+ * on-chain caps are the bound across processes.
+ */
+const LEDGER = new Map();
+function spentBy(address, nowSeconds) {
+    const key = address.toLowerCase();
+    let list = LEDGER.get(key);
+    if (list === undefined) {
+        list = [];
+        LEDGER.set(key, list);
+    }
+    for (let i = list.length - 1; i >= 0; i--)
+        if (list[i].at <= nowSeconds - SPEND_WINDOW_SECONDS)
+            list.splice(i, 1);
+    return list;
+}
+/** Tests only: forget every signed voucher of this process. */
+export function resetSpendLedger() {
+    LEDGER.clear();
+}
+function accountOn(value, chainId) {
+    const parsed = typeof value === "string" ? parseCaip10(value) : null;
+    return parsed && parsed.chainId === chainId ? parsed.address : null;
+}
+export class Eip155Scheme {
+    o;
+    namespace = "eip155";
+    /** The payer of the first voucher this client signed (G4): a different one later is refused. */
+    #recordedPayer = null;
+    constructor(o) {
+        this.o = o;
+    }
+    async prepare(input) {
+        const signer = input.signer;
+        let localKey;
+        try {
+            localKey = getAddress(signer.address);
+        }
+        catch {
+            return { ok: false, guard: "G5", code: "G5_LOCAL_KEY_INVALID", reason: "the signer's address is not readable" };
+        }
+        const networks = this.o.networks;
+        const req = isObject(input.requirement) ? input.requirement : null;
+        const entry = req && typeof req.network === "string" ? networks.get(req.network) : undefined;
+        const payer = entry ? accountOn(req?.payer, entry.chainId) : null;
+        // Before any chain read, as the reference does: these refusals say what to do.
+        if (entry && payer === localKey) {
+            return {
+                ok: false,
+                guard: "G5",
+                code: "G5_LOCAL_KEY_IS_PAYER",
+                reason: "the signer is the payer; use a dedicated payment key",
+            };
+        }
+        if (entry && accountOn(req?.delegate, entry.chainId) !== localKey) {
+            return {
+                ok: false,
+                guard: "G5",
+                code: "G5_DELEGATE_MISMATCH",
+                reason: "this signer is not the payment key bound to this API key; call paidCalls.bind() and approve it",
+            };
+        }
+        const chain = entry && payer ? await this.o.chain.read(entry, payer, localKey) : null;
+        const quote = await input.quote(input.tool);
+        // No await from here to the spend record, so two calls in flight cannot both pass the cap.
+        const nowSeconds = Math.floor(this.o.now() / 1000);
+        const signed = spentBy(localKey, nowSeconds);
+        const ctx = {
+            requirement: input.requirement,
+            forwardedCall: { tool: input.tool, at: input.calledAt },
+            quote,
+            chain,
+            localKey,
+            recordedPayer: this.#recordedPayer,
+            limits: {
+                perCall: this.o.limits.maxPerCall,
+                perDay: this.o.limits.maxPerDay,
+                confirmAbove: null,
+                providers: null,
+            },
+            signed,
+            confirmation: null,
+            nowSeconds,
+        };
+        const built = guardAndBuild(ctx, correctedNow(nowSeconds, this.o.dateOffset()), networks);
+        if (!built.ok) {
+            if ((built.guard === "G4" || built.guard === "G6") && entry && payer)
+                this.o.chain.invalidate(entry.id, payer, localKey);
+            return built;
+        }
+        const r = req;
+        const providerId = r.providerId;
+        if (typeof providerId !== "string" || providerId.length === 0 || providerId.length > 256) {
+            return { ok: false, guard: "G1", code: "G1_NOT_A_REQUIREMENT", reason: "the payment request names no provider" };
+        }
+        const reserved = { at: nowSeconds, amount: built.typedData.message.amount.toString() };
+        signed.push(reserved);
+        let used = false;
+        return {
+            ok: true,
+            details: {
+                tool: input.tool,
+                network: r.network,
+                amount: { ...built.wire.amount },
+                provider: r.provider,
+                payer: r.payer,
+                idempotencyKey: input.idempotencyKey,
+            },
+            sign: async () => {
+                if (used)
+                    throw new Error("a voucher is signed at most once");
+                used = true;
+                const signature = await signer.signTypedData(built.typedData);
+                if (typeof signature !== "string" || !/^0x[0-9a-fA-F]{130}$/.test(signature))
+                    throw new Error("the signer did not return a 65-byte signature");
+                this.#recordedPayer ??= getAddress(parseCaip10(r.payer).address);
+                return voucherEnvelope(built.wire, signature, providerId, r.contractVersion);
+            },
+            release: () => {
+                const list = spentBy(localKey, Math.floor(this.o.now() / 1000));
+                const i = list.indexOf(reserved);
+                if (i !== -1)
+                    list.splice(i, 1);
+            },
+        };
+    }
+    async onRefused(code, input) {
+        if (code !== "PAYMENT_VOUCHER_DELEGATE_INACTIVE")
+            return;
+        const req = isObject(input.requirement) ? input.requirement : null;
+        const networks = this.o.networks;
+        const entry = req && typeof req.network === "string" ? networks.get(req.network) : undefined;
+        const payer = entry ? accountOn(req?.payer, entry.chainId) : null;
+        if (entry && payer)
+            this.o.chain.invalidate(entry.id, payer, getAddress(input.signer.address));
+    }
+}

package/dist/schemes/types.d.ts

@@ -0,0 +1,54 @@
+import type { PriceQuote } from "../core/meta.js";
+import type { Money } from "../core/voucher.js";
+import type { Signer } from "../signer.js";
+/** What a caller's `onPayment` hook sees before anything is signed. */
+export interface PaymentDetails {
+    /** The tool being paid for. */
+    tool: string;
+    /** CAIP-2. */
+    network: string;
+    /** The exact amount, in atomic units of `amount.asset`. */
+    amount: Money;
+    /** CAIP-10 of the provider paid. */
+    provider: string;
+    /** CAIP-10 of the payer (the escrow owner). */
+    payer: string;
+    /** The idempotency key of this logical call. */
+    idempotencyKey: string;
+}
+export interface PrepareInput {
+    /** `_meta["x402/paymentRequired"]` as received. Untrusted. */
+    requirement: unknown;
+    /** The tool the call was for. */
+    tool: string;
+    /** When the unsigned attempt was sent, Unix seconds (local clock). */
+    calledAt: number;
+    signer: Signer;
+    idempotencyKey: string;
+    /** The quote for a tool (G3) on the calling client's URL: cached from list/search/get, or a fresh `get_tool`. */
+    quote: (tool: string) => Promise<PriceQuote | null>;
+}
+export type Prepared = {
+    ok: true;
+    details: PaymentDetails;
+    /** Signs the checked voucher; returns the `assay/voucher` envelope. Call at most once. */
+    sign(): Promise<Record<string, unknown>>;
+    /** Gives back the spend reserved for this voucher, when it is not signed after all. */
+    release(): void;
+} | {
+    ok: false;
+    guard: string;
+    code: string;
+    reason: string;
+};
+/**
+ * One payment scheme per CAIP-2 namespace. `call()` only sees this interface, so a new chain is a
+ * new scheme module (plus its vectors and signer variant), with no change to `call()`.
+ */
+export interface PaymentScheme {
+    readonly namespace: string;
+    /** Runs every local guard and builds the voucher. Nothing is signed here. */
+    prepare(input: PrepareInput): Promise<Prepared>;
+    /** Told about a server refusal of a signed voucher (for example a revoked key). */
+    onRefused(code: string, input: PrepareInput): Promise<void>;
+}

package/dist/schemes/types.js

@@ -0,0 +1 @@
+export {};

package/dist/signer.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Signers. The SDK never holds, stores or creates a key: the caller passes a signer, and the SDK
+ * hands it only typed data the SDK built itself after every local check passed.
+ *
+ * `Signer` is a tagged union keyed by CAIP-2 namespace, so other chains can be added as new
+ * variants without changing the existing ones.
+ */
+/** EIP-712 typed data, as viem and eth-account take it. Integers may be bigints. */
+export interface TypedData {
+    domain: Record<string, unknown>;
+    types: Record<string, readonly {
+        name: string;
+        type: string;
+    }[]>;
+    primaryType: string;
+    message: Record<string, unknown>;
+}
+/** An EVM key: any object with an address and an EIP-712 signer (a viem account, a KMS, an HSM). */
+export interface EvmSigner {
+    readonly namespace: "eip155";
+    /** The key's `0x` address. */
+    readonly address: string;
+    /** Signs EIP-712 typed data; returns the 65-byte `r || s || v` signature as `0x` hex. */
+    signTypedData(typedData: TypedData): Promise<string> | string;
+}
+/** A signer for one CAIP-2 namespace. Only `eip155` exists in this release. */
+export type Signer = EvmSigner;
+/** The parts of a viem `Account` (`privateKeyToAccount`, `toAccount`) that `evmSigner` uses. */
+export interface ViemLikeAccount {
+    readonly address: string;
+    signTypedData(typedData: never): Promise<string>;
+}
+/**
+ * Wraps a viem account as an {@link EvmSigner}. The returned object has only the address and the
+ * signing function: no key, and nothing else of the account, is reachable through it.
+ */
+export declare function evmSigner(account: ViemLikeAccount): EvmSigner;
+/** The namespace a signer is for, or `null` when it is not a signer. */
+export declare function signerNamespace(value: unknown): string | null;

package/dist/signer.js

@@ -0,0 +1,29 @@
+/**
+ * Signers. The SDK never holds, stores or creates a key: the caller passes a signer, and the SDK
+ * hands it only typed data the SDK built itself after every local check passed.
+ *
+ * `Signer` is a tagged union keyed by CAIP-2 namespace, so other chains can be added as new
+ * variants without changing the existing ones.
+ */
+/**
+ * Wraps a viem account as an {@link EvmSigner}. The returned object has only the address and the
+ * signing function: no key, and nothing else of the account, is reachable through it.
+ */
+export function evmSigner(account) {
+    const address = account.address;
+    return Object.freeze({
+        namespace: "eip155",
+        address,
+        signTypedData: (typedData) => account.signTypedData(typedData),
+        toJSON: () => ({ namespace: "eip155", address }),
+    });
+}
+/** The namespace a signer is for, or `null` when it is not a signer. */
+export function signerNamespace(value) {
+    if (typeof value !== "object" || value === null)
+        return null;
+    const s = value;
+    return typeof s.namespace === "string" && typeof s.address === "string" && typeof s.signTypedData === "function"
+        ? s.namespace
+        : null;
+}

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+/** This package's version, sent in the user agent. */
+export declare const VERSION = "0.1.0";

package/dist/version.js

@@ -0,0 +1,2 @@
+/** This package's version, sent in the user agent. */
+export const VERSION = "0.1.0";

package/package.json

@@ -1,6 +1,69 @@
 {
   "name": "@goassay-ai/sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Call tools through Assay over MCP, with free and paid calls signed by your own key.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/assay-ai/assay-sdk.git",
+    "directory": "node"
+  },
+  "homepage": "https://docs.goassay.ai/developers",
+  "bugs": {
+    "url": "https://github.com/assay-ai/assay-sdk/issues"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json",
+    "./core": {
+      "types": "./dist/core/index.d.ts",
+      "default": "./dist/core/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "lint": "eslint . && prettier --check .",
+    "format": "prettier --write .",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@noble/hashes": "1.8.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "10.0.1",
+    "@types/node": "22.20.5",
+    "eslint": "10.12.0",
+    "globals": "17.13.0",
+    "prettier": "3.9.9",
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.71.0",
+    "viem": "2.57.3",
+    "vitest": "5.0.3"
+  },
+  "peerDependencies": {
+    "viem": ">=2"
+  },
+  "peerDependenciesMeta": {
+    "viem": {
+      "optional": true
+    }
+  }
+}