@blindmarket/sdk 0.6.4 → 0.7.0

package/dist/onchain.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Sending the client's own transactions: the deploy fee, escrow funding and
+ * refunds. Everything here runs before, or right after, value moves, so each
+ * check fails before anything is sent, and a hash is handed back the moment it
+ * exists.
+ */
+import { ethers } from 'ethers';
+/**
+ * How long to wait for a receipt. Arc and Base confirm in seconds, so this
+ * bounds a stuck RPC, not a slow chain. The transaction may still confirm
+ * after it.
+ */
+export declare const DEFAULT_CONFIRM_TIMEOUT_MS = 180000;
+export interface SendOptions {
+    /**
+     * Called with the hash as soon as the transaction is broadcast, before any
+     * wait, and again with the replacement's hash if the wallet re-prices it.
+     * Persist it there: a crash from then on cannot lose it. A throwing callback
+     * does not stop the send, which has already happened.
+     */
+    onSent?: (hash: string) => void | Promise<void>;
+    timeoutMs?: number;
+    nonce?: number;
+    value?: bigint;
+    gasLimit?: bigint;
+    /** What the caller should do with the hash when the send could not be confirmed. */
+    unconfirmedHint?: (hash: string) => string;
+}
+/** A transaction that was broadcast but not seen to confirm. It may still land. */
+export declare class UnconfirmedTransactionError extends Error {
+    hash: string;
+    constructor(hash: string, message: string);
+}
+/**
+ * Send a transaction and wait for it to confirm. Returns the hash that
+ * confirmed: a sped-up transaction's replacement when the wallet re-priced it.
+ * A revert or a cancel throws an Error saying nothing moved. A send that could
+ * not be confirmed throws UnconfirmedTransactionError naming the hash.
+ */
+export declare function sendAndWait(signer: ethers.Signer, tx: {
+    to: string;
+    data: string;
+}, opts?: SendOptions): Promise<{
+    hash: string;
+    nonce: number;
+}>;
+/**
+ * Throw, before anything is sent, unless `signer` is connected to chain
+ * `chainId`. A transaction signed on the wrong network can succeed there
+ * (a USDC address with no code accepts any call) and pay nobody.
+ */
+export declare function assertSignerChain(signer: ethers.Signer, chainId: number | bigint, what: string): Promise<void>;
+export declare function tokenBalance(signer: ethers.Signer, token: string, owner: string): Promise<bigint>;
+/**
+ * Make sure `spender` may pull `amount` of `token` from the signer: approve
+ * exactly `amount` when the allowance is short. Returns the nonce the next
+ * transaction should use when an approve was sent (an RPC can answer the
+ * next nonce lookup from before the approve landed), else undefined.
+ */
+export declare function ensureAllowance(signer: ethers.Signer, token: string, spender: string, amount: bigint, opts?: Pick<SendOptions, 'timeoutMs'>): Promise<number | undefined>;

package/dist/onchain.js

@@ -0,0 +1,122 @@
+/**
+ * Sending the client's own transactions: the deploy fee, escrow funding and
+ * refunds. Everything here runs before, or right after, value moves, so each
+ * check fails before anything is sent, and a hash is handed back the moment it
+ * exists.
+ */
+import { ethers } from 'ethers';
+import { ApiError } from './apiError.js';
+/**
+ * How long to wait for a receipt. Arc and Base confirm in seconds, so this
+ * bounds a stuck RPC, not a slow chain. The transaction may still confirm
+ * after it.
+ */
+export const DEFAULT_CONFIRM_TIMEOUT_MS = 180_000;
+/** A transaction that was broadcast but not seen to confirm. It may still land. */
+export class UnconfirmedTransactionError extends Error {
+    hash;
+    constructor(hash, message) {
+        super(message);
+        this.hash = hash;
+        this.name = 'UnconfirmedTransactionError';
+    }
+}
+async function notify(onSent, hash) {
+    if (!onSent)
+        return;
+    try {
+        await onSent(hash);
+    }
+    catch {
+        // The transaction is out whatever the callback did; the caller still gets the hash.
+    }
+}
+/**
+ * Send a transaction and wait for it to confirm. Returns the hash that
+ * confirmed: a sped-up transaction's replacement when the wallet re-priced it.
+ * A revert or a cancel throws an Error saying nothing moved. A send that could
+ * not be confirmed throws UnconfirmedTransactionError naming the hash.
+ */
+export async function sendAndWait(signer, tx, opts = {}) {
+    const sent = await signer.sendTransaction({
+        to: tx.to,
+        data: tx.data,
+        ...(opts.value !== undefined ? { value: opts.value } : {}),
+        ...(opts.nonce !== undefined ? { nonce: opts.nonce } : {}),
+        ...(opts.gasLimit !== undefined ? { gasLimit: opts.gasLimit } : {}),
+    });
+    await notify(opts.onSent, sent.hash);
+    try {
+        const receipt = await sent.wait(1, opts.timeoutMs ?? DEFAULT_CONFIRM_TIMEOUT_MS);
+        if (receipt && receipt.status === 0)
+            throw new Error(`Transaction ${sent.hash} reverted, so nothing was paid.`);
+        return { hash: sent.hash, nonce: sent.nonce };
+    }
+    catch (err) {
+        if (ethers.isError(err, 'TRANSACTION_REPLACED')) {
+            if (err.cancelled)
+                throw new Error(`Transaction ${sent.hash} was cancelled or replaced in the wallet, so nothing was paid.`);
+            const replacement = err.replacement;
+            if (err.receipt && err.receipt.status === 0)
+                throw new Error(`Transaction ${replacement.hash} reverted, so nothing was paid.`);
+            await notify(opts.onSent, replacement.hash);
+            return { hash: replacement.hash, nonce: replacement.nonce };
+        }
+        if (ethers.isError(err, 'CALL_EXCEPTION'))
+            throw new Error(`Transaction ${sent.hash} reverted, so nothing was paid.`);
+        if (err instanceof Error && err.message.startsWith(`Transaction ${sent.hash}`))
+            throw err;
+        const hint = opts.unconfirmedHint ? ` ${opts.unconfirmedHint(sent.hash)}` : '';
+        throw new UnconfirmedTransactionError(sent.hash, `Transaction ${sent.hash} was sent but not confirmed (${err.message}).${hint}`);
+    }
+}
+/**
+ * Throw, before anything is sent, unless `signer` is connected to chain
+ * `chainId`. A transaction signed on the wrong network can succeed there
+ * (a USDC address with no code accepts any call) and pay nobody.
+ */
+export async function assertSignerChain(signer, chainId, what) {
+    const provider = signer.provider;
+    if (!provider) {
+        throw new ApiError(400, `${what} happens on chain ${chainId}, but the signer has no provider to check its chain with. Nothing was sent.`, undefined, 'NO_RPC');
+    }
+    let actual;
+    try {
+        actual = (await provider.getNetwork()).chainId;
+    }
+    catch (err) {
+        throw new ApiError(503, `${what}: could not read the signer's chain (${err.message}). Nothing was sent.`, undefined, 'RPC_UNREACHABLE');
+    }
+    if (actual !== BigInt(chainId)) {
+        throw new ApiError(409, `${what} happens on chain ${chainId}, but the signer's RPC is on chain ${actual}. Nothing was sent. Point the signer at an RPC for chain ${chainId}.`, undefined, 'WRONG_CHAIN');
+    }
+}
+const ERC20 = new ethers.Interface([
+    'function allowance(address owner, address spender) view returns (uint256)',
+    'function approve(address spender, uint256 amount) returns (bool)',
+    'function balanceOf(address owner) view returns (uint256)',
+]);
+/** An ERC-20 read through the signer's provider. */
+async function erc20Read(signer, token, fn, args) {
+    const provider = signer.provider;
+    if (!provider)
+        throw new ApiError(400, 'The signer has no provider to read the token with.', undefined, 'NO_RPC');
+    const raw = await provider.call({ to: token, data: ERC20.encodeFunctionData(fn, args) });
+    return ERC20.decodeFunctionResult(fn, raw)[0];
+}
+export function tokenBalance(signer, token, owner) {
+    return erc20Read(signer, token, 'balanceOf', [owner]);
+}
+/**
+ * Make sure `spender` may pull `amount` of `token` from the signer: approve
+ * exactly `amount` when the allowance is short. Returns the nonce the next
+ * transaction should use when an approve was sent (an RPC can answer the
+ * next nonce lookup from before the approve landed), else undefined.
+ */
+export async function ensureAllowance(signer, token, spender, amount, opts = {}) {
+    const owner = await signer.getAddress();
+    if ((await erc20Read(signer, token, 'allowance', [owner, spender])) >= amount)
+        return undefined;
+    const { nonce } = await sendAndWait(signer, { to: token, data: ERC20.encodeFunctionData('approve', [spender, amount]) }, opts);
+    return nonce + 1;
+}

package/dist/tools/helpers.js

@@ -91,17 +91,17 @@ export function createBlindMarketTools(bb) {
         }, async (a) => {
             return bb.deliverResult(a.taskId, { output: a.output });
         }, ['taskId', 'output']),
-        tool(bb, 'deploy_agent', 'Deploy a new AI agent on BlindMarket', {
+        tool(bb, 'deploy_agent', "Deploy a new hosted AI agent on BlindMarket, owned by the API key's wallet. Deploying costs a fee that this tool never pays: pass feeTxHash, the transaction in which the owner paid it, or the call fails with DEPLOY_FEE_REQUIRED and says what to pay.", {
             name: str('Agent name'),
             instructions: str('System prompt / instructions'),
-            provider: str('LLM provider', ['openai', 'anthropic', 'groq', 'gemini']),
-            model: str('Model name (e.g. gpt-4, claude-sonnet-4-5)'),
-            apiKey: str('Provider API key'),
-            ownerAddress: str('Owner wallet address (0x...)'),
-            ownerPublicKey: str('Owner public key'),
+            provider: str('LLM provider', ['openai', 'anthropic', 'groq', 'gemini', '0g-compute']),
+            model: str('Model name (e.g. gpt-4o-mini, claude-sonnet-4-5)'),
+            apiKey: str("Provider API key; not needed for 0g-compute, which bills the agent's own wallet"),
+            ownerPublicKey: str("Owner's uncompressed secp256k1 public key: 130 hex chars starting 04, no 0x. The agent's private key is encrypted to it."),
+            feeTxHash: str('The transaction that paid the deploy fee'),
         }, async (a) => {
             return bb.deployAgent(a);
-        }, ['name', 'instructions', 'provider', 'model', 'apiKey', 'ownerAddress', 'ownerPublicKey']),
+        }, ['name', 'instructions', 'provider', 'model', 'ownerPublicKey']),
         tool(bb, 'list_agents', 'List deployed agents', {
             ownerAddress: str('Filter by owner address'),
         }, async (a) => {

package/dist/types.d.ts

@@ -89,7 +89,10 @@ export interface OpenTask {
 export interface CreateTaskRequest {
     /** bytes32 commitment to the brief (0x + 64 hex) — sha256 of the ciphertext. */
     taskHash: Hex;
-    /** Payment token address (USDC on Base; the zero address = native on 0G). */
+    /**
+     * The posting chain's settlement token: USDC on Arc and Base; the zero
+     * address = native 0G. GET /health/settlement names it.
+     */
     token: Address;
     /** Reward, as an integer string in the payment token's smallest unit. */
     amount: string;
@@ -123,7 +126,11 @@ export interface CreateTaskTx {
         to: Address;
         data: Hex;
         value?: string;
+        from?: Address;
     };
+    /** The chain the tx must be sent on (the backend's posting chain). Absent from older backends. */
+    chain?: string;
+    chainId?: number;
 }
 export interface TaskDetail extends OpenTask {
     metadata?: Record<string, unknown>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blindmarket/sdk",
-  "version": "0.6.4",
+  "version": "0.7.0",
   "description": "BlindMarket SDK — deploy agents, assign workers, verify evidence",
   "author": "BlindMarket Team",
   "license": "MIT",