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

package/dist/relay/relay.js

@@ -0,0 +1,426 @@
+import { isTransient } from '../errors.js';
+import { getFile, getPurchase, rpcReply, view } from '../near/rpc.js';
+import { registerText } from '../near/texts.js';
+// Preserve dependency evaluation order before the split modules enter the relay cycle.
+import '../net/retry.js';
+import '../pay/base.js';
+import '../pay/split.js';
+import { identityJson, verifyAuthorization } from '../settle-near/identity.js';
+import { parsePurchaseMessage } from '../settle-near/purchase.js';
+import { termsHash } from '../settle-near/terms.js';
+import { admissionBalance, checkAdmissionFloor } from './admission.js';
+import './fees.js';
+import { runKeeper } from './keeper-runner.js';
+import { requestHash } from './ledger.js';
+import './reservation.js';
+import './sponsorship.js';
+import { checkRelay } from './relay-checks.js';
+import { durableStatus } from './relay-reconciliation.js';
+import { canonicalRequest, contractArgs } from './relay-request.js';
+import { send, sign } from './relay-transactions.js';
+import { fail, RelayError, } from './relay-types.js';
+import { admitTerms, relayLimits, temporary } from './sponsorship.js';
+export { checkRelay } from './relay-checks.js';
+export { reconcileRelayStorage } from './relay-reconciliation.js';
+export { canonicalRequest, contractArgs } from './relay-request.js';
+export { RelayError } from './relay-types.js';
+const asRelayError = (e) => {
+    if (e instanceof RelayError)
+        throw e;
+    return fail(isTransient(e) ? 'transport' : 'bad_request', e.message);
+};
+/** Gas for every call: `unlock` needs 150 Tgas, MPC's callbacks use the rest; unused gas returns. */
+const GAS = 300000000000000n;
+/**
+ * Prepaid storage counted per write (`register`, `unlock`, `reopen`): more than any of them takes
+ * (an unlock reserves 0.005 NEAR, a reopen marker under 0.001).
+ */
+const STORAGE_PER_WRITE = 10n ** 22n;
+// 0.01 NEAR
+/** An operation is held this long after it is sent, so a repeat doesn't burn gas on a refusal. */
+const HOLD = 15 * 60_000;
+/** How many more tries after the first send: the same bytes again, or after PENDING a lookup. */
+const RESENDS = 2;
+/** The first wait before trying again when NEAR says "later" or "pending"; it grows each try. */
+const RETRY_WAIT = 1_000;
+/** Requests waiting for their turn; past this the relayer answers busy. */
+const MAX_WAITING = 32;
+const accounts = new Map();
+const verifiedBaseTerms = new Set();
+const refusedBaseTerms = new Map();
+const queues = new Map();
+const statusReads = new WeakMap();
+const reconciliationCursor = new WeakMap();
+let waiting = 0;
+let checking = 0;
+const isObject = (v) => typeof v === 'object' && v !== null;
+/** The statuses of a transaction in a block (`NONE`: known, not yet in one). */
+const IN_BLOCK = new Set([
+    'INCLUDED',
+    'EXECUTED_OPTIMISTIC',
+    'INCLUDED_FINAL',
+    'EXECUTED',
+    'FINAL',
+]);
+const inBlock = (result) => {
+    const s = result
+        ?.final_execution_status;
+    return typeof s === 'string' && IN_BLOCK.has(s);
+};
+/** Ask for FINAL evidence by hash; a lost reply never proves rejection. */
+const lookUp = (url, tx, accountId) => rpcReply(url, 'tx', { tx_hash: tx, sender_account_id: accountId, wait_until: 'FINAL' }).catch(() => null);
+const senderKey = (o) => `${o.nearRpc}|${o.sender.accountId}|${o.sender.key}`;
+/**
+ * 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.
+ */
+const identity = (r) => {
+    if (r.method === 'unlock')
+        return `unlock:${JSON.parse(r.args.purchase).purchase.purchase_id}`;
+    if (r.method === 'claim_key')
+        return `claim:${r.args.purchase_id}:${r.args.grant ?? 0}`;
+    if (r.method === 'reopen')
+        return `reopen:${r.args.purchase_id}:${r.args.fresh_key}:${r.args.nonce}`;
+    if (r.method === 'register')
+        return `register:${r.args.terms.file_id}`;
+    if (r.method === 'fund_file_storage')
+        return `fund_file_storage:${r.args.file_id}:${r.args.nonce}`;
+    return `${r.method}:${r.args.file_id}:${r.args.key ?? ''}`;
+};
+const signedByItsWallet = (r, contract, assets) => {
+    if (r.method === 'register' &&
+        !verifyAuthorization(r.args.terms.seller, registerText(contract, r.args, assets), r.auth))
+        fail('bad_signature');
+};
+const quota = (r, p) => r.method === 'register'
+    ? [`register:${identityJson(r.args.terms.seller)}`, p.registrationsPerSeller ?? 20]
+    : r.method === 'claim_key'
+        ? [`claim:${r.args.purchase_id}:${r.args.grant ?? 0}`, p.claimsPerGrant ?? 3]
+        : r.method === 'reopen'
+            ? [`reopen:${r.args.purchase_id}`, p.reopensPerWalletFile ?? 10]
+            : null;
+const requestBinding = (r) => {
+    if (r.method !== 'register')
+        return r;
+    const { hostingReservation: _reservation, ...binding } = r;
+    return binding;
+};
+/** Runs jobs one at a time, in order: checks and nonces never interleave. */
+function enqueue(job, scope = 'relay') {
+    const next = (queues.get(scope) ?? Promise.resolve()).then(job, job);
+    queues.set(scope, next.catch(() => { }));
+    return next;
+}
+/** Read an already admitted operation without charging admission limits or sending anything. */
+export async function relayStatus(input, o) {
+    try {
+        const r = canonicalRequest(input, {
+            baseUsdc: o.usdc,
+            ...(o.nearUsdc ? { nearUsdc: o.nearUsdc } : {}),
+        });
+        return o.ledger ? durableStatus(r, o) : null;
+    }
+    catch (e) {
+        return asRelayError(e);
+    }
+}
+/** Every sponsored send reserves durable admission before signing. */
+export async function relay(input, o) {
+    const r = canonicalRequest(input, {
+        baseUsdc: o.usdc,
+        ...(o.nearUsdc ? { nearUsdc: o.nearUsdc } : {}),
+    });
+    if (!o.ledger)
+        return temporary(r.method === 'unlock');
+    try {
+        return await durableRelay(r, o, o.ledger);
+    }
+    catch (e) {
+        if (r.method === 'unlock' &&
+            e instanceof RelayError &&
+            (isTransient(e) ||
+                ['settlement_pending', 'relayer_unavailable', 'unavailable'].includes(e.code))) {
+            await deferPaidUnlock(r, o, e.retryAt ?? Date.now() + 30000);
+            if (e.code !== 'settlement_pending')
+                return temporary(true, e.retryAt ?? Date.now() + 30000);
+        }
+        throw e;
+    }
+}
+/** Retain bounded paid work while admission or the service is temporarily paused. */
+export async function deferPaidUnlock(input, o, nextAt) {
+    if (!o.ledger)
+        return;
+    const r = canonicalRequest(input, {
+        baseUsdc: o.usdc,
+        ...(o.nearUsdc ? { nearUsdc: o.nearUsdc } : {}),
+    });
+    if (r.method !== 'unlock')
+        return;
+    try {
+        await o.ledger.defer(identity(r), r, requestHash(requestBinding(r)), nextAt, o.policy.maxWaiting ?? 32);
+    }
+    catch (e) {
+        o.alert?.('paid_work_full');
+        throw e;
+    }
+    o.alert?.('paid_unlock_delayed');
+}
+async function durableRelay(r, o, ledger) {
+    if (!(await ledger.cutover())) {
+        o.alert?.('cutover_unsealed');
+        return temporary(true);
+    }
+    const previous = await durableStatus(r, o);
+    if (previous === 'pending')
+        return fail('in_flight');
+    if (previous)
+        return previous;
+    const deferred = (await ledger.read()).work[identity(r)];
+    if (deferred && deferred.nextAt > Date.now()) {
+        if (deferred.requestHash !== requestHash(requestBinding(r)))
+            return fail('bad_request');
+        const e = new RelayError('settlement_pending');
+        e.retryAt = deferred.nextAt;
+        throw e;
+    }
+    if (waiting >= (o.policy.maxWaiting ?? MAX_WAITING) ||
+        checking >= (o.policy.maxChecking ?? MAX_WAITING))
+        return temporary(r.method === 'unlock');
+    checking++;
+    try {
+        await checkRelay(r, o);
+        await checkAdmissionFloor(r.method, {
+            ...o,
+            admissionBalance: o.admissionBalance ?? (() => admissionBalance(o.nearRpc, o.sender.accountId)),
+        });
+    }
+    catch (e) {
+        if (r.method === 'unlock' &&
+            e instanceof RelayError &&
+            (isTransient(e) || ['unavailable', 'relayer_unavailable'].includes(e.code)))
+            return temporary(true);
+        throw e;
+    }
+    finally {
+        checking--;
+    }
+    waiting++;
+    try {
+        return await enqueue(async () => {
+            const previous = await durableStatus(r, o);
+            if (previous === 'pending')
+                return fail('in_flight');
+            if (previous)
+                return previous;
+            if ('deadline' in r.args && r.args.deadline < (o.now ?? Math.floor(Date.now() / 1000)))
+                return fail('bad_deadline');
+            if (r.method === 'register' &&
+                r.hostingReservation &&
+                r.hostingReservation.expiresAt <= (o.now ?? Math.floor(Date.now() / 1000)))
+                return fail('not_sponsored');
+            const purchase = r.method === 'unlock'
+                ? parsePurchaseMessage(r.args.purchase, { baseUsdc: o.usdc })
+                : r.method === 'claim_key' || r.method === 'reopen'
+                    ? await getPurchase(o.nearRpc, o.contractId, r.args.purchase_id)
+                    : null;
+            const fileId = r.method === 'register'
+                ? r.args.terms.file_id
+                : 'file_id' in r.args
+                    ? r.args.file_id
+                    : purchase?.file_id;
+            if (!fileId)
+                return fail('unknown_file');
+            const file = r.method === 'register' ? null : await getFile(o.nearRpc, o.contractId, fileId);
+            const terms = r.method === 'register' ? r.args.terms : file?.terms;
+            if (!terms)
+                return fail('unknown_file');
+            const hash = termsHash(terms, {
+                baseUsdc: o.usdc,
+                ...(o.nearUsdc ? { nearUsdc: o.nearUsdc } : {}),
+            });
+            let decision = await ledger.decision(fileId, hash);
+            if (r.method === 'register') {
+                const listed = await o.policy.sellerAllowed?.(identityJson(terms.seller));
+                decision = await admitTerms(terms, o, listed ? 'listed' : 'pool');
+            }
+            const listed = decision?.listed ?? false;
+            const allocation = r.method === 'register'
+                ? listed
+                    ? (o.policy.listedFileBudget ?? 5n * 10n ** 22n)
+                    : (o.policy.fileBudget ?? 41n * 10n ** 21n)
+                : r.method === 'fund_file_storage'
+                    ? BigInt(r.args.amount)
+                    : 0n;
+            if (r.method === 'register') {
+                // Query the unchanged contract's current admission floor before making an offer usable.
+                const protocol = await rpcReply(o.nearRpc, 'EXPERIMENTAL_protocol_config', {
+                    finality: 'final',
+                });
+                const byteCost = protocol.result?.runtime_config?.storage_amount_per_byte;
+                if (protocol.error ||
+                    typeof byteCost !== 'string' ||
+                    !/^[0-9]+$/.test(byteCost) ||
+                    BigInt(byteCost) <= 0n ||
+                    allocation < BigInt(byteCost) * 4096n)
+                    return temporary();
+            }
+            const write = ['register', 'unlock', 'reopen', 'reopen_seller', 'fund_file_storage'].includes(r.method);
+            const storage = write
+                ? (r.method === 'fund_file_storage'
+                    ? 0n
+                    : (o.policy.storagePerWrite ?? STORAGE_PER_WRITE)) + allocation
+                : 0n;
+            if (write) {
+                const balance = await view(o.nearRpc, o.contractId, 'storage_balance_of', {
+                    account_id: o.sender.accountId,
+                });
+                const floor = r.method === 'unlock' ? 0n : (o.policy.prepaidUnlockFloor ?? 10n ** 24n);
+                if (typeof balance !== 'string' ||
+                    !/^[0-9]+$/.test(balance) ||
+                    BigInt(balance) < floor + storage + (await ledger.pendingStorage()))
+                    return temporary(r.method === 'unlock');
+            }
+            if (decision && r.method === 'register')
+                decision.allocated = String(allocation);
+            const id = identity(r), binding = requestHash(requestBinding(r));
+            const q = quota(r, o.policy);
+            try {
+                const prepared = await ledger.prepare({
+                    id,
+                    requestHash: binding,
+                    method: r.method,
+                    fileId,
+                    termsHash: hash,
+                    seller: identityJson(terms.seller),
+                    listed,
+                    ip: o.ip ?? 'unknown',
+                    storage: String(storage),
+                    allocation: String(allocation),
+                    limits: relayLimits(o),
+                    ...(decision && r.method === 'register' ? { decision } : {}),
+                    ...(q && r.method !== 'register' ? { quota: { key: q[0], limit: q[1] } } : {}),
+                    ...(r.method === 'register' && r.hostingReservation
+                        ? {
+                            reservation: {
+                                key: `${r.hostingReservation.hostOrigin}|${r.hostingReservation.uploadId}`,
+                                binding,
+                            },
+                        }
+                        : {}),
+                    ...(r.method === 'fund_file_storage'
+                        ? {
+                            fundingBalanceBefore: String(file?.purchaseStorageBalance ?? 0n),
+                            nonce: `${identityJson(terms.seller)}|${r.args.nonce}`,
+                            nonceDeadline: r.args.deadline,
+                            topup: {
+                                lifetime: String(listed
+                                    ? (o.policy.listedTopupPerFile ?? 15n * 10n ** 22n)
+                                    : (o.policy.topupPerFile ?? 82n * 10n ** 21n)),
+                                fileDay: String(listed
+                                    ? (o.policy.listedTopupPerFileDay ?? 5n * 10n ** 22n)
+                                    : (o.policy.topupPerFileDay ?? 41n * 10n ** 21n)),
+                                totalDay: String(o.policy.topupPerDay ?? 5n * 10n ** 23n),
+                                listedReserved: String(o.policy.topupListedReserved ?? 25n * 10n ** 22n),
+                            },
+                        }
+                        : {}),
+                });
+                if (prepared.capacityReached)
+                    o.alert?.('ledger_capacity');
+                if (!prepared.fresh)
+                    return (prepared.operation.result ??
+                        (prepared.operation.tx
+                            ? { txHash: prepared.operation.tx.txHash, uncertain: true }
+                            : fail('in_flight')));
+            }
+            catch (e) {
+                if (e instanceof RelayError && e.code === 'relayer_unavailable')
+                    o.alert?.('ledger_capacity');
+                if (r.method === 'unlock' && e instanceof RelayError && e.code === 'limited') {
+                    const pending = new RelayError('settlement_pending');
+                    if (e.retryAt !== undefined)
+                        pending.retryAt = e.retryAt;
+                    throw pending;
+                }
+                throw e;
+            }
+            let signed = false;
+            try {
+                const args = r.method === 'register'
+                    ? {
+                        args: {
+                            ...r.args,
+                            ...(allocation > 0n ? { file_budget: String(allocation) } : {}),
+                        },
+                        auth: r.auth,
+                    }
+                    : contractArgs(r);
+                const tx = await sign(o, senderKey(o), r.method, args);
+                await ledger.signed(id, { ...tx, signer: o.sender.accountId, args });
+                signed = true;
+                const result = await send(o, senderKey(o), tx.txHash, tx.signed);
+                if (result.rejected) {
+                    await ledger.reject(id);
+                    return temporary(r.method === 'unlock');
+                }
+                await ledger.result(id, result);
+                if (r.method === 'register') {
+                    const final = await getFile(o.nearRpc, o.contractId, fileId).catch(() => null);
+                    if (final?.termsHash === hash)
+                        await ledger.registered(fileId, hash);
+                }
+                if (result.uncertain)
+                    o.alert?.('uncertain');
+                return result;
+            }
+            catch (e) {
+                if (!signed && !(await ledger.operation(id))?.tx)
+                    await ledger.reject(id);
+                throw e;
+            }
+        }, senderKey(o));
+    }
+    finally {
+        waiting--;
+    }
+}
+/** Resume due paid work without creating a second purchase or losing its frozen policy. */
+export async function retryPaidUnlocks(o) {
+    if (!o.ledger)
+        return;
+    for (const [id, work] of Object.entries((await o.ledger.read()).work)) {
+        if (work.nextAt > Date.now())
+            continue;
+        try {
+            await relay(work.request, o);
+        }
+        catch (e) {
+            if (e instanceof RelayError &&
+                [
+                    'taken_down',
+                    'sales_stopped',
+                    'payment_used',
+                    'payment_not_found',
+                    'bad_request',
+                    'not_sponsored',
+                    'unknown_file',
+                    'file_mismatch',
+                    'bad_signature',
+                ].includes(e.code))
+                await o.ledger.finishWork(id);
+        }
+    }
+}
+/** A dedicated account/key has its own nonce queue, independent from relay traffic. */
+export async function keep(o) {
+    const key = senderKey(o);
+    return enqueue(() => runKeeper(o, {
+        sign: (method, args, gas) => sign(o, key, method, args, gas),
+        send: (hash, signed) => send(o, key, hash, signed, true),
+    }), key);
+}
+// Load-time declarations stay together in their original evaluation order.
+export { accounts, asRelayError, enqueue, fail, GAS, HOLD, IN_BLOCK, identity, inBlock, isObject, lookUp, quota, RESENDS, RETRY_WAIT, reconciliationCursor, refusedBaseTerms, requestBinding, senderKey, signedByItsWallet, statusReads, verifiedBaseTerms, };

package/dist/relay/reservation.d.ts

@@ -0,0 +1,29 @@
+import { type Identity } from '../settle-near/identity.js';
+import { type Terms } from '../settle-near/terms.js';
+export interface HostingReservation {
+    v: 1;
+    uploadId: string;
+    network: string;
+    contract: string;
+    fileId: string;
+    termsHash: string;
+    seller: Identity;
+    cipherHash: string;
+    byteSize: number;
+    plaintextSize: number;
+    headerSize: number;
+    metadataHash: string;
+    hostOrigin: string;
+    issuedAt: number;
+    expiresAt: number;
+    signature: string;
+}
+export declare const reservationText: (r: Omit<HostingReservation, "signature">) => string;
+export declare function parseReservation(input: unknown): HostingReservation;
+export declare function verifyReservation(input: unknown, terms: Terms, o: {
+    hostOrigin: string;
+    publicKey: string;
+    now: number;
+    fetch?: typeof fetch;
+    maxFileBytes?: number;
+}): Promise<HostingReservation>;

package/dist/relay/reservation.js

@@ -0,0 +1,132 @@
+/** Verify host attestations against a fixed pinned origin and Ed25519 key. */
+import { ed25519 } from '@noble/curves/ed25519.js';
+import { base64urlnopad } from '@scure/base';
+import { bytes, exactKeys } from '../settle-near/codec.js';
+import { identityJson, identityText } from '../settle-near/identity.js';
+import { termsHash } from '../settle-near/terms.js';
+export const reservationText = (r) => [
+    'Annon: hosting reservation v1',
+    `upload: ${r.uploadId}`,
+    `network: ${r.network}`,
+    `contract: ${r.contract}`,
+    `file: ${r.fileId}`,
+    `terms: ${r.termsHash}`,
+    `seller: ${identityText(r.seller)}`,
+    `cipher: ${r.cipherHash}`,
+    `bytes: ${r.byteSize}`,
+    `plaintext bytes: ${r.plaintextSize}`,
+    `header bytes: ${r.headerSize}`,
+    `metadata: ${r.metadataHash}`,
+    `host: ${r.hostOrigin}`,
+    `issued: ${r.issuedAt}`,
+    `expires: ${r.expiresAt}`,
+].join('\n');
+export function parseReservation(input) {
+    exactKeys(input, [
+        'v',
+        'uploadId',
+        'network',
+        'contract',
+        'fileId',
+        'termsHash',
+        'seller',
+        'cipherHash',
+        'byteSize',
+        'plaintextSize',
+        'headerSize',
+        'metadataHash',
+        'hostOrigin',
+        'issuedAt',
+        'expiresAt',
+        'signature',
+    ]);
+    const r = input;
+    if (r.v !== 1 ||
+        !/^[0-9a-f]{64}$/.test(r.uploadId) ||
+        typeof r.signature !== 'string' ||
+        !/^[A-Za-z0-9_-]{86}$/.test(r.signature))
+        throw new TypeError('Invalid hosting reservation.');
+    for (const k of ['fileId', 'termsHash', 'cipherHash', 'metadataHash'])
+        bytes(r[k], 32);
+    for (const k of ['byteSize', 'plaintextSize', 'headerSize', 'issuedAt', 'expiresAt'])
+        if (!Number.isSafeInteger(r[k]) || r[k] < 0)
+            throw new TypeError('Invalid hosting reservation.');
+    const origin = new URL(r.hostOrigin);
+    if (origin.protocol !== 'https:' ||
+        origin.origin !== r.hostOrigin ||
+        r.byteSize < 1 ||
+        r.byteSize > 50086016 ||
+        r.plaintextSize > 50000000 ||
+        r.headerSize < 1 ||
+        r.headerSize > 65536 ||
+        r.byteSize <= r.headerSize ||
+        r.expiresAt !== r.issuedAt + 600)
+        throw new TypeError('Invalid hosting reservation.');
+    identityText(r.seller);
+    return r;
+}
+export async function verifyReservation(input, terms, o) {
+    const r = parseReservation(input);
+    if (r.plaintextSize > (o.maxFileBytes ?? 50000000) ||
+        r.hostOrigin !== o.hostOrigin ||
+        r.network !== terms.network ||
+        r.contract !== terms.contract ||
+        r.fileId !== terms.file_id ||
+        r.cipherHash !== terms.cipher_hash ||
+        r.termsHash !==
+            termsHash(terms, {
+                nearUsdc: terms.near.token,
+                ...(terms.base ? { baseUsdc: terms.base.usdc } : {}),
+            }) ||
+        identityJson(r.seller) !== identityJson(terms.seller) ||
+        r.issuedAt > o.now ||
+        r.expiresAt <= o.now ||
+        !/^[0-9a-f]{64}$/.test(o.publicKey) ||
+        !ed25519.verify(base64urlnopad.decode(r.signature), new TextEncoder().encode(reservationText(r)), bytes(`0x${o.publicKey}`, 32), { zip215: false }))
+        throw new TypeError('Invalid hosting reservation.');
+    const response = await (o.fetch ?? fetch)(`${o.hostOrigin}/v1/upload-reservations/${r.uploadId}`, {
+        credentials: 'omit',
+        redirect: 'error',
+        signal: AbortSignal.timeout(5000),
+    });
+    if (!response.ok ||
+        response.redirected ||
+        response.headers.get('content-type')?.split(';')[0]?.trim().toLowerCase() !== 'application/json')
+        throw new TypeError('Hosting reservation unavailable.');
+    const reader = response.body?.getReader();
+    if (!reader)
+        throw new TypeError('Hosting reservation unavailable.');
+    const parts = [];
+    let size = 0;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            size += value.length;
+            if (size > 16384)
+                throw new TypeError('Hosting reservation unavailable.');
+            parts.push(value);
+        }
+    }
+    finally {
+        await reader.cancel();
+    }
+    const raw = new Uint8Array(size);
+    let at = 0;
+    for (const part of parts) {
+        raw.set(part, at);
+        at += part.length;
+    }
+    const live = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(raw));
+    exactKeys(live, ['state', 'fileId', 'termsHash', 'expiresAt', 'reservation']);
+    const liveReservation = parseReservation(live.reservation);
+    if (live.state !== 'reserved' ||
+        live.fileId !== r.fileId ||
+        live.termsHash !== r.termsHash ||
+        live.expiresAt !== r.expiresAt ||
+        reservationText(liveReservation) !== reservationText(r) ||
+        liveReservation.signature !== r.signature)
+        throw new TypeError('Hosting reservation is not live.');
+    return r;
+}

package/dist/relay/sponsorship.d.ts

@@ -0,0 +1,42 @@
+/** Durable sponsorship admission. A later policy change cannot revoke a checked listing. */
+import { type FileInfo } from '../near/rpc.js';
+import { type Terms } from '../settle-near/terms.js';
+import type { RelayLimits, SponsorshipDecision } from './ledger.js';
+import { type CheckOptions } from './relay.js';
+export declare const ZERO_FEE: {
+    fixed: string;
+    bps: number;
+    treasuryNear: null;
+    treasuryEvm: null;
+};
+export declare const relayLimits: (o: CheckOptions) => RelayLimits;
+export declare const temporary: (paid?: boolean, retryAt?: number) => never;
+export declare function admitTerms(terms: Terms, o: CheckOptions, tier: SponsorshipDecision['tier'], skipFee?: boolean): Promise<SponsorshipDecision>;
+export declare function checkedDecision(file: FileInfo, o: CheckOptions, paid?: boolean): Promise<SponsorshipDecision>;
+export declare function baseEligibility(fileId: string, hash: string, o: CheckOptions, paid?: boolean): Promise<{
+    network: string;
+    contract: string;
+    fileId: string;
+    termsHash: string;
+    eligible: true;
+    tier: "legacy" | "listed" | "pool" | "external";
+    policyVersion: string;
+    minPrice: string;
+    fee: import("./fees.js").ProtocolFee;
+    decidedAt: number;
+    checkedAt: number;
+    reason?: never;
+} | {
+    network: string;
+    contract: string;
+    fileId: string;
+    termsHash: string;
+    eligible: false;
+    reason: "not_sponsored";
+    tier: "external";
+    policyVersion: string;
+    minPrice: string;
+    fee: import("./fees.js").ProtocolFee;
+    decidedAt: number;
+    checkedAt: number;
+}>;