@defdone/annon 0.0.0-stage → 0.1.0-alpha.0

package/dist/relay/relay-request.js

@@ -0,0 +1,139 @@
+/** Relay request canonicalization, contract arguments and operation identity. */
+import { bytes, exactKeys, uint } from '../settle-near/codec.js';
+import { buyerKey, parsePurchaseMessage } from '../settle-near/purchase.js';
+import { termsHash } from '../settle-near/terms.js';
+import { fail } from './relay-types.js';
+import { parseReservation } from './reservation.js';
+export function canonicalRequest(input, assets) {
+    try {
+        const r = structuredClone(input);
+        if (!r || typeof r !== 'object')
+            throw new Error('expected request');
+        exactKeys(r, [
+            'method',
+            'args',
+            ...('auth' in r ? ['auth'] : []),
+            ...('baseSplit' in r ? ['baseSplit'] : []),
+            ...('hostingReservation' in r ? ['hostingReservation'] : []),
+        ]);
+        if ('hostingReservation' in r) {
+            if (r.method !== 'register')
+                throw new Error('invalid hosting reservation');
+            r.hostingReservation = parseReservation(r.hostingReservation);
+        }
+        if ('baseSplit' in r) {
+            if (r.method !== 'register' || !r.baseSplit)
+                throw new Error('invalid split provenance');
+            exactKeys(r.baseSplit, ['kind', 'salt']);
+            if (!['push', 'pull'].includes(r.baseSplit.kind))
+                throw new Error('invalid split kind');
+            bytes(r.baseSplit.salt, 32);
+        }
+        if ('auth' in r) {
+            if (!['register', 'reopen', 'reopen_seller', 'stop_sales', 'fund_file_storage'].includes(r.method))
+                throw new Error('unexpected authorization');
+            exactKeys(r.auth, ['kind', 'sig']);
+            if (!['evm', 'solana'].includes(r.auth.kind))
+                throw new Error('invalid auth kind');
+            bytes(r.auth.sig, r.auth.kind === 'evm' ? 65 : 64);
+        }
+        const a = r.args;
+        switch (r.method) {
+            case 'fund_file_storage':
+                exactKeys(a, ['file_id', 'amount', 'nonce', 'deadline']);
+                bytes(r.args.nonce, 32);
+                bytes(r.args.file_id, 32);
+                if (uint(r.args.amount, 128) <= 0n)
+                    throw new Error('positive topup required');
+                break;
+            case 'register':
+                exactKeys(a, ['terms', 'seller_key', 'deadline']);
+                termsHash(r.args.terms, assets);
+                buyerKey(r.args.seller_key);
+                break;
+            case 'reopen':
+                exactKeys(a, ['purchase_id', 'fresh_key', 'nonce', 'deadline']);
+                bytes(r.args.purchase_id, 32);
+                buyerKey(r.args.fresh_key);
+                bytes(r.args.nonce, 32);
+                break;
+            case 'reopen_seller':
+            case 'stop_sales':
+                exactKeys(a, ['file_id', 'key', 'deadline']);
+                bytes(r.args.file_id, 32);
+                if (r.method === 'reopen_seller')
+                    buyerKey(r.args.key ?? '');
+                else if (r.args.key !== null)
+                    throw new Error('stop key must be null');
+                break;
+            case 'claim_key':
+                exactKeys(a, ['purchase_id', ...('grant' in a ? ['grant'] : [])]);
+                bytes(r.args.purchase_id, 32);
+                if (r.args.grant !== undefined &&
+                    (!Number.isInteger(r.args.grant) || r.args.grant < 0 || r.args.grant > 0xffffffff))
+                    throw new Error('invalid grant');
+                r.args.grant = r.args.grant ?? 0;
+                break;
+            case 'unlock':
+                exactKeys(a, ['purchase', 'logs', 'header']);
+                if (parsePurchaseMessage(r.args.purchase, assets).route !== 'base-usdc')
+                    throw new Error('not a Base purchase');
+                if (!Array.isArray(r.args.logs) ||
+                    r.args.logs.length !== 2 ||
+                    (r.args.header !== null && !/^0x([0-9a-f]{2})+$/.test(r.args.header)))
+                    throw new Error('invalid logs/header');
+                r.args.logs = r.args.logs.map((input) => {
+                    const fields = [
+                        'address',
+                        'block_hash',
+                        'block_number',
+                        'data',
+                        'log_index',
+                        'removed',
+                        'topics',
+                        'transaction_hash',
+                        'transaction_index',
+                    ];
+                    exactKeys(input, [...fields]);
+                    for (const key of ['address', 'block_hash', 'transaction_hash'])
+                        bytes(`0x${input[key]}`, key === 'address' ? 20 : 32);
+                    if (!Array.isArray(input.topics) || input.topics.length !== 3)
+                        throw new Error('invalid log topics');
+                    for (const topic of input.topics)
+                        bytes(`0x${topic}`, 32);
+                    for (const key of ['block_number', 'log_index', 'transaction_index'])
+                        if (!Number.isSafeInteger(input[key]) || input[key] < 0)
+                            throw new Error('invalid log index');
+                    if (input.removed !== false ||
+                        typeof input.data !== 'string' ||
+                        input.data.length > 256 ||
+                        !/^0x(?:[0-9a-f]{2})*$/.test(input.data))
+                        throw new Error('invalid log data');
+                    return Object.fromEntries(fields.map((k) => [k, input[k]]));
+                });
+                break;
+            default:
+                throw new Error('unknown method');
+        }
+        if ('deadline' in a) {
+            if (!Number.isSafeInteger(a.deadline))
+                throw new Error('invalid deadline');
+            uint(String(a.deadline), 64);
+        }
+        if (['register', 'reopen', 'stop_sales', 'reopen_seller', 'fund_file_storage'].includes(r.method) &&
+            !('auth' in r))
+            throw new Error('auth required; NEAR identities call directly');
+        return r;
+    }
+    catch (e) {
+        return fail('bad_request', e.message);
+    }
+}
+/** Contract wire shape: unlock and identity calls wrap args; claim_key is flat. */
+export const contractArgs = (r) => r.method === 'fund_file_storage'
+    ? { file_id: r.args.file_id, amount: r.args.amount }
+    : 'auth' in r
+        ? { args: r.args, auth: r.auth }
+        : r.method === 'unlock'
+            ? { args: r.args }
+            : r.args;

package/dist/relay/relay-transactions.d.ts

@@ -0,0 +1,23 @@
+/** NEAR transaction signing, submission retries and RPC evidence helpers. */
+import { type RelayResult, type Sender } from './relay-types.js';
+/** Signs one function call, no deposit, with the sender's key (one account per key, so near-api-js
+ * numbers its nonces locally across calls). */
+declare function sign(o: {
+    nearRpc: string;
+    contractId: string;
+    sender: Sender;
+}, key: string, method: string, args: object, gas?: bigint): Promise<{
+    signed: string;
+    referenceHash?: string;
+    txHash: string;
+}>;
+/**
+ * Sends signed bytes; after a lost or unclear answer, looks the transaction up and sends the same
+ * bytes again (same hash). Only definite validation refusals are reported as not sent.
+ */
+declare function send(o: {
+    nearRpc: string;
+    sender: Sender;
+}, key: string, txHash: string, signed: string, keeper?: boolean, unknownFinal?: boolean): Promise<RelayResult>;
+export { lookUp, senderKey } from './relay.js';
+export { send, sign };

package/dist/relay/relay-transactions.js

@@ -0,0 +1,182 @@
+/** NEAR transaction signing, submission retries and RPC evidence helpers. */
+import { sha256 } from '@noble/hashes/sha2.js';
+import { base58, base64 } from '@scure/base';
+import { Account, actions, encodeTransaction, JsonRpcProvider } from 'near-api-js';
+import { RPC_TIMEOUT_MS, rpcReply } from '../near/rpc.js';
+import { sleep } from '../net/retry.js';
+import { accounts, GAS, inBlock, isObject, lookUp, RESENDS, RETRY_WAIT } from './relay.js';
+import { fail } from './relay-types.js';
+/**
+ * The provider near-api-js signs with: it reads the key's nonce and a recent block. Every reply
+ * that sends a transaction or looks one up goes through `rpcReply` instead (its id checked, one
+ * fetch, aborted at the deadline).
+ */
+// Note: the timer ends the wait, not the request (near-api-js 7.4 takes no AbortSignal).
+function signingProvider(url) {
+    const p = new JsonRpcProvider({ url });
+    const send = p.sendJsonRpc.bind(p);
+    p.sendJsonRpc = ((method, params) => {
+        let timer;
+        const late = new Promise((_, no) => {
+            timer = setTimeout(() => no(new Error(`NEAR RPC ${method} timed out`)), RPC_TIMEOUT_MS);
+        });
+        return Promise.race([send(method, params), late]).finally(() => clearTimeout(timer));
+    });
+    return p;
+}
+/**
+ * What NEAR's error guide (docs.near.org/api/rpc/transactions#error-handling) says to do after an
+ * error: send the same bytes again now or `later`, only look it up (`pending`), ask a node that
+ * tracks its shard (`elsewhere`), or `stop`: the same node would give the same answer.
+ */
+function advice(e) {
+    const refused = e.data
+        ?.TxExecutionError?.InvalidTxError;
+    // Nodes before nearcore 2.14 send no `cause.info`: the same as NOT_OBSERVED.
+    const timeout = e.cause?.name === 'TIMEOUT_ERROR'
+        ? (e.cause.info?.cause ?? 'NOT_OBSERVED')
+        : undefined;
+    if (e.cause?.name === 'DOES_NOT_TRACK_SHARD' || timeout === 'DOES_NOT_TRACK_SHARD')
+        return 'elsewhere';
+    if (timeout === 'PENDING')
+        return 'pending';
+    if (timeout === 'NOT_OBSERVED')
+        return 'again';
+    const busy = isObject(refused) && ('ShardCongested' in refused || 'ShardStuck' in refused);
+    if (busy || e.name === 'INTERNAL_ERROR' || timeout === 'ERROR')
+        return 'later';
+    return 'stop';
+}
+/** NEAR's own words for an error: the transaction's refusal, or the whole error. */
+function describe(e) {
+    const { name, cause, data, message } = e;
+    const refused = data
+        ?.TxExecutionError?.InvalidTxError;
+    return JSON.stringify(refused ?? { name, cause, data, message });
+}
+/** Signs one function call, no deposit, with the sender's key (one account per key, so near-api-js
+ * numbers its nonces locally across calls). */
+async function sign(o, key, method, args, gas = GAS) {
+    let account = accounts.get(key);
+    if (!account) {
+        account = new Account(o.sender.accountId, signingProvider(o.nearRpc), o.sender.key);
+        accounts.set(key, account);
+    }
+    const tx = await account
+        .createSignedTransaction({
+        receiverId: o.contractId,
+        actions: [actions.functionCall(method, args, gas, 0n)],
+    })
+        .catch(() => fail('transport', 'NEAR signing is unavailable.'));
+    return {
+        txHash: base58.encode(sha256(tx.transaction.encode())),
+        ...(tx.transaction.blockHash?.length === 32
+            ? { referenceHash: base58.encode(Uint8Array.from(tx.transaction.blockHash)) }
+            : {}),
+        signed: base64.encode(encodeTransaction(tx)),
+    };
+}
+/**
+ * Sends signed bytes; after a lost or unclear answer, looks the transaction up and sends the same
+ * bytes again (same hash). Only definite validation refusals are reported as not sent.
+ */
+async function send(o, key, txHash, signed, keeper = false, unknownFinal = false) {
+    const unclear = (reason) => ({ txHash, uncertain: true, reason });
+    let reason = 'no clear answer from NEAR';
+    // After NEAR said it has the transaction (a PENDING timeout), the relayer only looks it up.
+    let look = false;
+    let ambiguous = false;
+    try {
+        for (let attempt = 0; attempt <= RESENDS; attempt++) {
+            const reply = look
+                ? undefined
+                : await rpcReply(o.nearRpc, 'send_tx', {
+                    signed_tx_base64: signed,
+                    wait_until: 'INCLUDED',
+                }).catch(() => null);
+            if (reply && !reply.error && inBlock(reply.result))
+                return { txHash };
+            const legacy = reply?.error?.data;
+            const info = reply?.error?.cause?.info;
+            const refused = legacy?.TxExecutionError?.InvalidTxError ?? info?.InvalidTxError;
+            const variant = typeof refused === 'string'
+                ? refused
+                : isObject(refused)
+                    ? Object.keys(refused)[0]
+                    : undefined;
+            // InvalidNonce can mean these very bytes already landed. Unknown variants are ambiguous too.
+            const definite = new Set([
+                'NotEnoughBalance',
+                'NotEnoughAllowance',
+                'InvalidAccessKeyError',
+                'InvalidSignerId',
+                'SignerDoesNotExist',
+                'InvalidReceiverId',
+                'InvalidSignature',
+                'CostOverflow',
+                'InvalidChain',
+                'Expired',
+                'ActionsValidation',
+                'TransactionSizeExceeded',
+            ]);
+            if (unknownFinal)
+                definite.add('InvalidNonce');
+            if (variant !== undefined && definite.has(variant)) {
+                accounts.delete(key);
+                if (ambiguous) {
+                    const status = await lookUp(o.nearRpc, txHash, o.sender.accountId);
+                    if (status && !status.error && inBlock(status.result))
+                        return { txHash };
+                    return unclear('an earlier submission may have landed before this validation refusal');
+                }
+                // Only the variant name is public; RPC data may echo arbitrary transaction fields.
+                return {
+                    txHash,
+                    rejected: true,
+                    reason: variant && /^[A-Za-z]+$/.test(variant) ? variant : 'InvalidTxError',
+                };
+            }
+            ambiguous = true;
+            // The chain is past the nonces given out here: later operations read it afresh, whether or
+            // not this one landed.
+            if (variant === 'InvalidNonce')
+                accounts.delete(key);
+            const status = await lookUp(o.nearRpc, txHash, o.sender.accountId);
+            if (status && !status.error && inBlock(status.result))
+                return { txHash };
+            // A refusal doesn't prove nothing landed (a node may accept a transaction and refuse it on
+            // a later check in the same call), so it is unclear too. Errors of the send and of the
+            // lookup are taken as NEAR's guide says; an unknown transaction is only "not seen yet".
+            let later = false;
+            for (const [what, e] of [
+                ['send', reply?.error],
+                [
+                    'lookup',
+                    status?.error?.cause?.name === 'UNKNOWN_TRANSACTION' ? undefined : status?.error,
+                ],
+            ]) {
+                if (!e)
+                    continue;
+                const next = advice(e);
+                reason = `NEAR answered the ${what}: ${describe(e)}`;
+                if (next === 'elsewhere')
+                    return unclear(`${reason}; ask a NEAR RPC that tracks its shard`);
+                if (what === 'send' && (next === 'stop' || (keeper && next !== 'pending')))
+                    return unclear(reason);
+                if (next === 'pending')
+                    look = true;
+                if (next === 'later')
+                    later = true;
+            }
+            // Note: sends wait in line meanwhile, at most 3 s per transaction.
+            if (attempt < RESENDS && (later || look))
+                await sleep(RETRY_WAIT * (attempt + 1));
+        }
+        return unclear(reason);
+    }
+    catch {
+        return unclear('NEAR submission is unresolved.');
+    }
+}
+export { lookUp, senderKey } from './relay.js';
+export { send, sign };

package/dist/relay/relay-types.d.ts

@@ -0,0 +1,128 @@
+/** Relay request, policy, sender and result types with shared errors. */
+import { AnnonError } from '../errors.js';
+import type { FileInfo } from '../near/rpc.js';
+import type { FileFundingArgs, RegisterArgs, ReopenArgs, SellerArgs } from '../near/texts.js';
+import type { EvmLog } from '../pay/base.js';
+import type { Authorization } from '../settle-near/identity.js';
+import type { AdmissionOptions } from './admission.js';
+import type { ProtocolFee } from './fees.js';
+import type { RelayLedger, RelayLimits } from './ledger.js';
+import type { HostingReservation } from './reservation.js';
+export type RelayRequest = {
+    method: 'fund_file_storage';
+    args: FileFundingArgs;
+    auth: Authorization;
+} | {
+    method: 'register';
+    args: RegisterArgs;
+    auth: Authorization;
+    baseSplit?: {
+        kind: 'push' | 'pull';
+        salt: string;
+    };
+    hostingReservation?: HostingReservation;
+} | {
+    method: 'reopen';
+    args: ReopenArgs;
+    auth: Authorization;
+} | {
+    method: 'stop_sales' | 'reopen_seller';
+    args: SellerArgs;
+    auth: Authorization;
+} | {
+    method: 'claim_key';
+    args: {
+        purchase_id: string;
+        grant?: number;
+    };
+} | {
+    method: 'unlock';
+    args: {
+        purchase: string;
+        logs: EvmLog[];
+        header: string | null;
+    };
+};
+export type RelayErrorCode = 'budget' | 'bad_request' | 'bad_signature' | 'bad_deadline' | 'not_sponsored' | 'limited' | 'duplicate' | 'in_flight' | 'unavailable' | 'unknown_file' | 'already_registered' | 'sales_stopped' | 'taken_down' | 'not_buyer' | 'payment_not_found' | 'settlement_pending' | 'relayer_unavailable' | 'payment_used' | 'bad_header' | 'transport';
+export interface RelayPolicy {
+    minPrice: bigint;
+    baseSponsorship?: boolean;
+    openPoolEnabled?: boolean;
+    listedRegistrationsPerSeller?: number;
+    unlocksPerFile?: number;
+    unlocksPerSeller?: number;
+    listedUnlocksPerFile?: number;
+    listedUnlocksPerSeller?: number;
+    listedTopupPerFile?: bigint;
+    listedTopupPerFileDay?: bigint;
+    topupListedReserved?: bigint;
+    prepaidUnlockFloor?: bigint;
+    storagePerWrite?: bigint;
+    topupMaxDeadlineSeconds?: number;
+    /** Listed sellers get a larger allocation; unlisted sellers remain eligible. */
+    fileBudget?: bigint;
+    listedFileBudget?: bigint;
+    fee?: ProtocolFee;
+    sponsoredFilesPerDay?: number;
+    topupPerFile?: bigint;
+    topupPerFileDay?: bigint;
+    topupPerDay?: bigint;
+    maxDeadlineSeconds: number;
+    /** Listed-seller predicate for allocation tiers; does not deny unlisted sellers. */
+    sellerAllowed?: (seller: string) => boolean | Promise<boolean>;
+    registrationsPerSeller?: number;
+    reopensPerWalletFile?: number;
+    /** Daily limit per (purchase, grant). */
+    claimsPerGrant?: number;
+    holdMs?: number;
+    maxWaiting?: number;
+    maxChecking?: number;
+}
+export interface CheckOptions extends AdmissionOptions {
+    nearRpc: string;
+    baseRpc: string;
+    contractId: string;
+    usdc: string;
+    nearUsdc?: string;
+    policy: RelayPolicy;
+    now?: number;
+    network?: string;
+    ledger?: RelayLedger;
+    admissionLimits?: Partial<RelayLimits>;
+    ip?: string;
+    acceptingNewBasePayments?: boolean;
+    historicalFile?: (fileId: string, blockHash: string) => Promise<FileInfo | null>;
+    reservation?: {
+        hostOrigin: string;
+        publicKey: string;
+        fetch?: typeof fetch;
+        maxFileBytes?: number;
+    };
+    alert?: (type: string) => void;
+}
+export interface Sender {
+    /** The NEAR account that sends and pays, e.g. `relayer.annon.defdone.near`. */
+    accountId: string;
+    /** Its function-call key for the relay methods, including file funding, `ed25519:…`. Only for this contract. */
+    key: string;
+}
+export interface RelayResult {
+    txHash: string;
+    /**
+     * NEAR's answer was lost or unclear (a timeout, a gateway error, a refusal): the transaction may
+     * or may not be in a block. Read its outcome by hash before asking again. Sending the same
+     * operation again is safe: the contract refuses it if the first one landed.
+     */
+    uncertain?: true;
+    /** RPC validation refused this submission before execution. */
+    rejected?: true;
+    /** With `uncertain` or `rejected`: what NEAR answered, for the operator. */
+    reason?: string;
+}
+export declare class RelayError extends AnnonError {
+    readonly code: RelayErrorCode;
+    retryAt?: number;
+    constructor(code: RelayErrorCode, message?: string);
+}
+declare const fail: (code: RelayErrorCode, message?: string) => never;
+export { fail };

package/dist/relay/relay-types.js

@@ -0,0 +1,17 @@
+/** Relay request, policy, sender and result types with shared errors. */
+import { AnnonError } from '../errors.js';
+export class RelayError extends AnnonError {
+    // A plain field, not a parameter property: the relayer runs this file with Node's type
+    // stripping, which has no parameter properties.
+    code;
+    retryAt;
+    constructor(code, message = code) {
+        super(code, message);
+        this.code = code;
+        this.name = 'RelayError';
+    }
+}
+const fail = (code, message) => {
+    throw new RelayError(code, message);
+};
+export { fail };

package/dist/relay/relay.d.ts

@@ -0,0 +1,102 @@
+/** Relay entry points, admission serialization and module-load state. */
+import type { Account } from 'near-api-js';
+import '../net/retry.js';
+import '../pay/base.js';
+import '../pay/split.js';
+import { type SettlementAssets } from '../settle-near/terms.js';
+import './fees.js';
+import { type KeepOptions, type KeepResult } from './keeper-runner.js';
+import type { RelayLedger } from './ledger.js';
+import './reservation.js';
+import './sponsorship.js';
+import { type CheckOptions, fail, type RelayPolicy, type RelayRequest, type RelayResult, type Sender } from './relay-types.js';
+export type { KeeperRecord, KeepOptions, KeepResult, RefundSource } from './keeper-runner.js';
+export { checkRelay } from './relay-checks.js';
+export { reconcileRelayStorage } from './relay-reconciliation.js';
+export { canonicalRequest, contractArgs } from './relay-request.js';
+export type { CheckOptions, RelayErrorCode, RelayPolicy, RelayRequest, RelayResult, Sender, } from './relay-types.js';
+export { RelayError } from './relay-types.js';
+declare const asRelayError: (e: unknown) => never;
+/** Gas for every call: `unlock` needs 150 Tgas, MPC's callbacks use the rest; unused gas returns. */
+declare const GAS = 300000000000000n;
+/** An operation is held this long after it is sent, so a repeat doesn't burn gas on a refusal. */
+declare const HOLD: number;
+/** How many more tries after the first send: the same bytes again, or after PENDING a lookup. */
+declare const RESENDS = 2;
+/** The first wait before trying again when NEAR says "later" or "pending"; it grows each try. */
+declare const RETRY_WAIT = 1000;
+declare const accounts: Map<string, Account>;
+declare const verifiedBaseTerms: Set<string>;
+declare const refusedBaseTerms: Map<string, number>;
+declare const statusReads: WeakMap<RelayLedger, Map<string, Promise<"pending" | RelayResult | null>>>;
+declare const reconciliationCursor: WeakMap<RelayLedger, number>;
+declare const isObject: (v: unknown) => v is object;
+/** The statuses of a transaction in a block (`NONE`: known, not yet in one). */
+declare const IN_BLOCK: Set<string>;
+declare const inBlock: (result: unknown) => boolean;
+/** Ask for FINAL evidence by hash; a lost reply never proves rejection. */
+declare const lookUp: (url: string, tx: string, accountId: string) => Promise<import("../near/rpc.js").RpcReply | null>;
+declare const senderKey: (o: {
+    nearRpc: string;
+    sender: Sender;
+}) => string;
+/**
+ * What makes two requests the same operation. Only a party that could make the request succeed
+ * can hold it: wallet signatures are checked against their authoritative identities before
+ * anything is held, and an unlock
+ * includes the buyer's key, which only the buyer knows before it is sent.
+ */
+declare const identity: (r: RelayRequest) => string;
+declare const signedByItsWallet: (r: RelayRequest, contract: string, assets?: SettlementAssets) => void;
+declare const quota: (r: RelayRequest, p: RelayPolicy) => [string, number] | null;
+declare const requestBinding: (r: RelayRequest) => {
+    method: "fund_file_storage";
+    args: import("../near/texts.js").FileFundingArgs;
+    auth: import("../settle-near/identity.js").Authorization;
+} | {
+    method: "reopen";
+    args: import("../near/texts.js").ReopenArgs;
+    auth: import("../settle-near/identity.js").Authorization;
+} | {
+    method: "stop_sales" | "reopen_seller";
+    args: import("../near/texts.js").SellerArgs;
+    auth: import("../settle-near/identity.js").Authorization;
+} | {
+    method: "claim_key";
+    args: {
+        purchase_id: string;
+        grant?: number;
+    };
+} | {
+    method: "unlock";
+    args: {
+        purchase: string;
+        logs: import("../pay/base.js").EvmLog[];
+        header: string | null;
+    };
+} | {
+    method: "register";
+    args: import("../near/texts.js").RegisterArgs;
+    auth: import("../settle-near/identity.js").Authorization;
+    baseSplit?: {
+        kind: "push" | "pull";
+        salt: string;
+    };
+};
+/** Runs jobs one at a time, in order: checks and nonces never interleave. */
+declare function enqueue<T>(job: () => Promise<T>, scope?: string): Promise<T>;
+/** Read an already admitted operation without charging admission limits or sending anything. */
+export declare function relayStatus(input: unknown, o: CheckOptions): Promise<RelayResult | 'pending' | null>;
+/** Every sponsored send reserves durable admission before signing. */
+export declare function relay(input: unknown, o: CheckOptions & {
+    sender: Sender;
+}): Promise<RelayResult>;
+/** Retain bounded paid work while admission or the service is temporarily paused. */
+export declare function deferPaidUnlock(input: unknown, o: CheckOptions, nextAt: number): Promise<void>;
+/** Resume due paid work without creating a second purchase or losing its frozen policy. */
+export declare function retryPaidUnlocks(o: CheckOptions & {
+    sender: Sender;
+}): Promise<void>;
+/** A dedicated account/key has its own nonce queue, independent from relay traffic. */
+export declare function keep(o: KeepOptions): Promise<KeepResult>;
+export { accounts, asRelayError, enqueue, fail, GAS, HOLD, IN_BLOCK, identity, inBlock, isObject, lookUp, quota, RESENDS, RETRY_WAIT, reconciliationCursor, refusedBaseTerms, requestBinding, senderKey, signedByItsWallet, statusReads, verifiedBaseTerms, };