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

package/dist/relay/sponsorship.js

@@ -0,0 +1,184 @@
+import { isTransient } from '../errors.js';
+/** Durable sponsorship admission. A later policy change cannot revoke a checked listing. */
+import { getFile } from '../near/rpc.js';
+import { readSplitState } from '../pay/split.js';
+import { termsHash } from '../settle-near/terms.js';
+import { checkProtocolFee } from './fees.js';
+import { RelayError } from './relay.js';
+export const ZERO_FEE = { fixed: '0', bps: 0, treasuryNear: null, treasuryEvm: null };
+export const relayLimits = (o) => ({
+    perDay: 1000,
+    unlock: 500,
+    unlockReserved: 500,
+    unlockListedReserved: 250,
+    unlocksPerFile: o.policy.unlocksPerFile ?? 10,
+    unlocksPerSeller: o.policy.unlocksPerSeller ?? 20,
+    listedUnlocksPerFile: o.policy.listedUnlocksPerFile ?? 100,
+    listedUnlocksPerSeller: o.policy.listedUnlocksPerSeller ?? 250,
+    files: o.policy.sponsoredFilesPerDay ?? 60,
+    filesPerIp: 2,
+    registrationsPerSeller: o.policy.registrationsPerSeller ?? 2,
+    listedRegistrationsPerSeller: o.policy.listedRegistrationsPerSeller ?? 20,
+    ...o.admissionLimits,
+});
+const now = (o) => o.now ?? Math.floor(Date.now() / 1000);
+export const temporary = (paid = false, retryAt = Date.now() + 30000) => {
+    const e = new RelayError(paid ? 'settlement_pending' : 'relayer_unavailable', 'Sponsorship is temporarily unavailable.');
+    e.retryAt = retryAt;
+    throw e;
+};
+export async function admitTerms(terms, o, tier, skipFee = false) {
+    const hash = termsHash(terms, {
+        baseUsdc: o.usdc,
+        ...(o.nearUsdc ? { nearUsdc: o.nearUsdc } : {}),
+    });
+    if (terms.network !== (o.network ?? 'near:mainnet') ||
+        terms.contract !== o.contractId ||
+        BigInt(terms.near.price) < o.policy.minPrice ||
+        (terms.base &&
+            (o.policy.baseSponsorship === false || BigInt(terms.base.price) < o.policy.minPrice)))
+        throw new RelayError('not_sponsored');
+    try {
+        if (!skipFee && o.policy.fee)
+            checkProtocolFee(terms, o.policy.fee);
+    }
+    catch {
+        throw new RelayError('not_sponsored');
+    }
+    if (terms.base) {
+        if (terms.near.recipients.some((r) => r.identity.kind !== 'evm'))
+            throw new RelayError('not_sponsored');
+        try {
+            await readSplitState(o.baseRpc, terms.base.pay_to, {
+                recipients: terms.near.recipients.map((r) => r.identity.id),
+                allocations: terms.near.recipients.map((r) => BigInt(r.bps)),
+                totalAllocation: 10000n,
+                distributionIncentive: 0,
+            });
+        }
+        catch (e) {
+            if (isTransient(e))
+                return temporary();
+            throw new RelayError('not_sponsored');
+        }
+    }
+    return {
+        network: terms.network,
+        contract: terms.contract,
+        fileId: terms.file_id,
+        termsHash: hash,
+        terms: structuredClone(terms),
+        eligible: true,
+        tier,
+        listed: tier === 'listed',
+        policyVersion: 'v1',
+        minPrice: String(o.policy.minPrice),
+        fee: structuredClone(skipFee ? ZERO_FEE : (o.policy.fee ?? ZERO_FEE)),
+        decidedAt: now(o),
+        allocated: null,
+        outcome: 'registered',
+    };
+}
+export async function checkedDecision(file, o, paid = false) {
+    const ledger = o.ledger;
+    if (!ledger)
+        return temporary(paid);
+    const existing = await ledger.decision(file.terms.file_id, file.termsHash);
+    if (existing) {
+        if (existing.outcome === 'prepared')
+            await ledger.registered(file.terms.file_id, file.termsHash);
+        return existing;
+    }
+    const cutover = await ledger.cutover();
+    if (!cutover)
+        return temporary(paid);
+    let historical;
+    try {
+        if (!o.historicalFile) {
+            o.alert?.('historical_unavailable');
+            return temporary(paid);
+        }
+        historical = await o.historicalFile(file.terms.file_id, cutover.blockHash);
+    }
+    catch {
+        o.alert?.('historical_unavailable');
+        return temporary(paid);
+    }
+    if (historical && historical.termsHash === file.termsHash) {
+        const inventory = cutover.inventory.includes(file.terms.file_id);
+        let decision;
+        try {
+            decision = await admitTerms(historical.terms, {
+                ...o,
+                policy: {
+                    ...o.policy,
+                    baseSponsorship: true,
+                    minPrice: BigInt(cutover.minPrice),
+                    fee: cutover.fee,
+                },
+            }, 'legacy', inventory);
+        }
+        catch (e) {
+            // Historical paid evidence cannot become a permanent refusal due to a missing policy input.
+            if (paid)
+                return temporary(true);
+            throw e;
+        }
+        decision.policyVersion = 'legacy-v0';
+        decision.listed = inventory;
+        return ledger.remember(decision);
+    }
+    if (o.policy.baseSponsorship === false || o.policy.openPoolEnabled === false)
+        return temporary(paid);
+    const decision = await admitTerms(file.terms, o, 'external');
+    return ledger.remember(decision);
+}
+export async function baseEligibility(fileId, hash, o, paid = false) {
+    try {
+        if (!paid && o.acceptingNewBasePayments === false)
+            return temporary();
+        const file = await getFile(o.nearRpc, o.contractId, fileId);
+        if (!file ||
+            file.termsHash !== hash ||
+            !file.terms.base ||
+            file.takenDown ||
+            (!paid && file.salesStoppedAt !== null))
+            throw new RelayError('not_sponsored');
+        const d = await checkedDecision(file, o, paid);
+        if (!paid && !(await o.ledger?.unlockAvailable(d, relayLimits(o), now(o) * 1000)))
+            return temporary(false, (Math.floor(now(o) / 86400) + 1) * 86400000);
+        return {
+            network: d.network,
+            contract: d.contract,
+            fileId,
+            termsHash: hash,
+            eligible: true,
+            tier: d.tier,
+            policyVersion: d.policyVersion,
+            minPrice: d.minPrice,
+            fee: d.fee,
+            decidedAt: d.decidedAt,
+            checkedAt: now(o),
+        };
+    }
+    catch (e) {
+        if (e instanceof RelayError && e.code === 'not_sponsored')
+            return {
+                network: o.network ?? 'near:mainnet',
+                contract: o.contractId,
+                fileId,
+                termsHash: hash,
+                eligible: false,
+                reason: 'not_sponsored',
+                tier: 'external',
+                policyVersion: 'v1',
+                minPrice: String(o.policy.minPrice),
+                fee: o.policy.fee ?? ZERO_FEE,
+                decidedAt: now(o),
+                checkedAt: now(o),
+            };
+        if (e instanceof RelayError)
+            throw e;
+        return temporary(paid);
+    }
+}

package/dist/routes.d.ts

@@ -0,0 +1,2 @@
+/** Public workflow routes. Protocol Purchase.route retains its wire vocabulary. */
+export type BuyRoute = 'near' | 'base' | '1click';

package/dist/routes.js

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

package/dist/settle-near/codec.d.ts

@@ -0,0 +1,17 @@
+/** Small bounded Borsh primitives; all integers here are little-endian. */
+export declare const utf8: TextEncoder;
+export declare const concat: (...parts: Uint8Array[]) => Uint8Array<ArrayBuffer>;
+export declare const hex: (b: Uint8Array) => string;
+export declare function bytes(s: string, length: number): Uint8Array<ArrayBuffer>;
+export declare function uint(s: string | bigint, bits: number): bigint;
+export declare function le(value: string | bigint | number, length: number): Uint8Array<ArrayBuffer>;
+export declare const str: (s: string) => Uint8Array<ArrayBuffer>;
+export declare const hash: (tag: string, data: Uint8Array) => string;
+export declare function account(s: string): string;
+export declare function network(s: string): string;
+export declare function exactKeys(value: unknown, keys: string[]): asserts value is Record<string, unknown>;
+export declare const compare: (a: Uint8Array, b: Uint8Array) => number;
+/** USDC base units in authoritative human-readable text. */
+export declare function usdc(units: string | bigint): string;
+/** Rust text::utc, including every u64 timestamp (no JavaScript Date limit). */
+export declare function utc(secs: number | bigint): string;

package/dist/settle-near/codec.js

@@ -0,0 +1,86 @@
+/** Small bounded Borsh primitives; all integers here are little-endian. */
+import { sha256 } from '@noble/hashes/sha2.js';
+import { concatParts, prefixedHex } from '../bytes.js';
+export const utf8 = new TextEncoder();
+export const concat = (...parts) => concatParts(parts);
+export const hex = (b) => prefixedHex(b);
+export function bytes(s, length) {
+    if (typeof s !== 'string' || !new RegExp(`^0x[0-9a-f]{${length * 2}}$`).test(s))
+        throw new TypeError(`expected canonical ${length}-byte hex`);
+    return Uint8Array.from(s.slice(2).match(/../g) ?? [], (x) => Number.parseInt(x, 16));
+}
+export function uint(s, bits) {
+    if (typeof s !== 'bigint' &&
+        (typeof s !== 'string' ||
+            s.length > Math.ceil(bits * Math.LOG10E * Math.LN2) ||
+            !/^(0|[1-9][0-9]*)$/.test(s)))
+        throw new TypeError('expected canonical unsigned integer');
+    const n = BigInt(s);
+    if (n < 0n || n >= 1n << BigInt(bits))
+        throw new RangeError(`expected u${bits}`);
+    return n;
+}
+export function le(value, length) {
+    if (typeof value === 'number' && !Number.isSafeInteger(value))
+        throw new RangeError('expected integer');
+    let n = uint(typeof value === 'number' ? BigInt(value) : value, length * 8);
+    return Uint8Array.from({ length }, () => {
+        const b = Number(n & 255n);
+        n >>= 8n;
+        return b;
+    });
+}
+export const str = (s) => {
+    const b = utf8.encode(s);
+    return concat(le(b.length, 4), b);
+};
+export const hash = (tag, data) => hex(sha256(concat(utf8.encode(tag), new Uint8Array([0]), data)));
+export function account(s) {
+    if (typeof s !== 'string' || !/^(?=.{2,64}$)[a-z0-9]+(?:[._-][a-z0-9]+)*$/.test(s))
+        throw new TypeError('invalid NEAR account id');
+    return s;
+}
+export function network(s) {
+    if (!['near:mainnet', 'near:testnet', 'near:sandbox'].includes(s))
+        throw new TypeError('invalid NEAR network');
+    return s;
+}
+export function exactKeys(value, keys) {
+    if (value === null ||
+        typeof value !== 'object' ||
+        Array.isArray(value) ||
+        Object.keys(value).length !== keys.length ||
+        !keys.every((k) => Object.hasOwn(value, k)))
+        throw new TypeError('unexpected object fields');
+}
+export const compare = (a, b) => {
+    for (let i = 0; i < Math.min(a.length, b.length); i++) {
+        const d = a[i] - b[i];
+        if (d)
+            return d;
+    }
+    return a.length - b.length;
+};
+/** USDC base units in authoritative human-readable text. */
+export function usdc(units) {
+    const u = uint(units, 128);
+    const part = u % 1000000n;
+    return `${u / 1000000n}${part ? `.${part.toString().padStart(6, '0').replace(/0+$/, '')}` : ''}`;
+}
+/** Rust text::utc, including every u64 timestamp (no JavaScript Date limit). */
+export function utc(secs) {
+    if (typeof secs === 'number' && !Number.isSafeInteger(secs))
+        throw new RangeError('deadline out of range');
+    const n = uint(BigInt(secs), 64);
+    const z = n / 86400n + 719468n;
+    const era = z / 146097n;
+    const doe = z % 146097n;
+    const yoe = (doe - doe / 1460n + doe / 36524n - doe / 146096n) / 365n;
+    const doy = doe - (365n * yoe + yoe / 4n - yoe / 100n);
+    const mp = (5n * doy + 2n) / 153n;
+    const day = doy - (153n * mp + 2n) / 5n + 1n;
+    const month = mp < 10n ? mp + 3n : mp - 9n;
+    const year = era * 400n + yoe + (month <= 2n ? 1n : 0n);
+    const pad = (v) => v.toString().padStart(2, '0');
+    return `${year.toString().padStart(4, '0')}-${pad(month)}-${pad(day)} ${pad((n % 86400n) / 3600n)}:${pad((n / 60n) % 60n)}:${pad(n % 60n)} UTC`;
+}

package/dist/settle-near/identity.d.ts

@@ -0,0 +1,27 @@
+export type Identity = {
+    kind: 'evm';
+    id: string;
+} | {
+    kind: 'solana';
+    id: string;
+} | {
+    kind: 'near';
+    id: string;
+};
+export type Authorization = {
+    kind: 'evm' | 'solana';
+    sig: string;
+};
+export declare const identityKind: (id: Identity) => number;
+/** Accept base58 Solana keys at the API boundary; store/serialize lowercase hex. */
+export declare function parseIdentity(input: unknown): Identity;
+export declare function encodeIdentity(input: Identity): Uint8Array<ArrayBuffer>;
+export declare const identityJson: (id: Identity) => string;
+export declare function identityText(input: Identity): string;
+/** Malformed signatures and auth of a different kind always fail closed. */
+export declare function verifyAuthorization(input: Identity, text: string, auth?: Authorization, predecessor?: string): boolean;
+/** Wallet Standard results must carry the very same message, before accepting their signature. */
+export declare function solanaWalletAuth(id: Identity, text: string, result: {
+    signature: Uint8Array;
+    signedMessage: Uint8Array;
+}): Authorization;

package/dist/settle-near/identity.js

@@ -0,0 +1,80 @@
+/** Identity and authoritative-text authorization, near-settlement.md §2. */
+import { ed25519 } from '@noble/curves/ed25519.js';
+import { base58 } from '@scure/base';
+import { signedBy } from '../envelope/evm.js';
+import { AnnonError } from '../errors.js';
+import { account, bytes, compare, concat, exactKeys, hex, str, utf8 } from './codec.js';
+export const identityKind = (id) => ({ evm: 0, solana: 1, near: 2 })[id.kind];
+/** Accept base58 Solana keys at the API boundary; store/serialize lowercase hex. */
+export function parseIdentity(input) {
+    exactKeys(input, ['kind', 'id']);
+    const { kind, id } = input;
+    if (typeof id !== 'string')
+        throw new TypeError('invalid identity id');
+    if (kind === 'near')
+        return { kind, id: account(id) };
+    if (kind === 'evm') {
+        const normalized = id.toLowerCase();
+        bytes(normalized, 20);
+        return { kind, id: normalized };
+    }
+    if (kind === 'solana') {
+        let raw;
+        if (/^[a-fA-F0-9]{64}$/.test(id))
+            raw = bytes(`0x${id.toLowerCase()}`, 32);
+        else {
+            if (id.length < 32 || id.length > 44)
+                throw new TypeError('invalid Solana key');
+            raw = base58.decode(id);
+            if (raw.length !== 32 || base58.encode(raw) !== id)
+                throw new TypeError('invalid Solana key');
+        }
+        return { kind, id: hex(raw).slice(2) };
+    }
+    throw new TypeError('unknown identity kind');
+}
+export function encodeIdentity(input) {
+    const id = parseIdentity(input);
+    return concat(new Uint8Array([identityKind(id)]), id.kind === 'near'
+        ? str(id.id)
+        : bytes(id.kind === 'evm' ? id.id : `0x${id.id}`, id.kind === 'evm' ? 20 : 32));
+}
+export const identityJson = (id) => JSON.stringify(parseIdentity(id));
+export function identityText(input) {
+    const id = parseIdentity(input);
+    return id.kind === 'near'
+        ? `NEAR ${id.id}`
+        : id.kind === 'evm'
+            ? `EVM ${id.id}`
+            : `Solana ${base58.encode(bytes(`0x${id.id}`, 32))}`;
+}
+/** Malformed signatures and auth of a different kind always fail closed. */
+export function verifyAuthorization(input, text, auth, predecessor) {
+    try {
+        const id = parseIdentity(input);
+        if (typeof text !== 'string' || text.includes('\r') || text.endsWith('\n'))
+            return false;
+        if (id.kind === 'near')
+            return auth === undefined && predecessor === id.id;
+        exactKeys(auth, ['kind', 'sig']);
+        if (auth.kind !== id.kind)
+            return false;
+        const sig = bytes(auth.sig, id.kind === 'evm' ? 65 : 64);
+        return id.kind === 'evm'
+            ? signedBy(text, sig, id.id)
+            : ed25519.verify(sig, utf8.encode(text), bytes(`0x${id.id}`, 32), { zip215: false });
+    }
+    catch {
+        return false;
+    }
+}
+/** Wallet Standard results must carry the very same message, before accepting their signature. */
+export function solanaWalletAuth(id, text, result) {
+    if (!(result.signedMessage instanceof Uint8Array) ||
+        compare(result.signedMessage, utf8.encode(text)) !== 0)
+        throw new AnnonError('invalid_signature', 'wallet returned different signed bytes');
+    const auth = { kind: 'solana', sig: hex(result.signature) };
+    if (id.kind !== 'solana' || !verifyAuthorization(id, text, auth))
+        throw new AnnonError('invalid_signature', 'the signature is not from the seller');
+    return auth;
+}

package/dist/settle-near/purchase.d.ts

@@ -0,0 +1,40 @@
+import { type Identity } from './identity.js';
+import { type SettlementAssets } from './terms.js';
+export interface Purchase {
+    version: 2;
+    refund: Identity;
+    network: string;
+    contract: string;
+    route: 'near-usdc' | 'base-usdc';
+    asset: string;
+    file_id: string;
+    terms_hash: string;
+    price: string;
+    nonce: string;
+    buyer_key: string;
+    recovery: Identity;
+    expires_at: string;
+}
+export declare function buyerKey(key: string): Uint8Array<ArrayBuffer>;
+export declare function encodePurchase(p: Purchase, assets?: SettlementAssets): Uint8Array<ArrayBuffer>;
+export declare const purchaseId: (p: Purchase, assets?: SettlementAssets) => string;
+export declare const baseNonceV2: (id: string) => string;
+/** The API accepts normalized identities; the wire always has one canonical encoding. */
+export declare function buildPurchaseMessage(p: Purchase, assets?: SettlementAssets): string;
+/** Reads only the first 160 bytes, independently of an invalid/oversized purchase body. */
+export declare function parseRefundPrefix(msg: string): Identity;
+/**
+ * Bounds work before JSON.parse, then compares with the canonical serializer. This also rejects
+ * duplicate/unknown fields at every level, alternate escapes, key order and whitespace.
+ */
+export declare function parsePurchaseMessage(msg: string, assets?: SettlementAssets): Purchase;
+export interface ReopenV2 {
+    contract: string;
+    purchase_id: string;
+    file_id: string;
+    recovery: Identity;
+    fresh_key: string;
+    nonce: string;
+    deadline: number;
+}
+export declare function reopenTextV2(a: ReopenV2): string;

package/dist/settle-near/purchase.js

@@ -0,0 +1,153 @@
+/** Purchase commitment, canonical wire message and recovery text, spec §§5,9. */
+import { bls12_381 as bls } from '@noble/curves/bls12-381.js';
+import { keccak_256 } from '@noble/hashes/sha3.js';
+import { account, bytes, concat, exactKeys, hash, hex, le, network, str, uint, utc, utf8, } from './codec.js';
+import { encodeIdentity, identityJson, identityText, parseIdentity, } from './identity.js';
+import { BASE_USDC, NEAR_USDC } from './terms.js';
+export function buyerKey(key) {
+    const raw = bytes(key, 48);
+    const point = bls.G1.Point.fromBytes(raw);
+    if (point.is0() || !point.isTorsionFree() || hex(point.toBytes(true)) !== key)
+        throw new TypeError('invalid buyer key');
+    return raw;
+}
+export function encodePurchase(p, assets = {}) {
+    exactKeys(p, [
+        'version',
+        'refund',
+        'network',
+        'contract',
+        'route',
+        'asset',
+        'file_id',
+        'terms_hash',
+        'price',
+        'nonce',
+        'buyer_key',
+        'recovery',
+        'expires_at',
+    ]);
+    if (p.version !== 2 || (p.route !== 'near-usdc' && p.route !== 'base-usdc'))
+        throw new TypeError('invalid purchase version/route');
+    if (p.route === 'near-usdc') {
+        network(p.network);
+        account(p.asset);
+        if ((assets.nearUsdc !== undefined || p.network === 'near:mainnet') &&
+            p.asset !== (assets.nearUsdc ?? NEAR_USDC))
+            throw new TypeError('invalid NEAR asset');
+    }
+    else {
+        if (p.network !== 'eip155:8453' || p.asset !== (assets.baseUsdc ?? BASE_USDC))
+            throw new TypeError('invalid Base network/asset');
+        bytes(p.asset, 20);
+    }
+    account(p.contract);
+    const amount = uint(p.price, 128);
+    if (amount === 0n)
+        throw new RangeError('price must be positive');
+    return concat(le(2, 1), encodeIdentity(p.refund), str(p.network), str(p.contract), le(p.route === 'near-usdc' ? 0 : 1, 1), str(p.asset), bytes(p.file_id, 32), bytes(p.terms_hash, 32), le(amount, 16), bytes(p.nonce, 32), buyerKey(p.buyer_key), encodeIdentity(p.recovery), le(uint(p.expires_at, 64), 8));
+}
+export const purchaseId = (p, assets) => hash('annon/purchase/v2', encodePurchase(p, assets));
+export const baseNonceV2 = (id) => hex(keccak_256(concat(utf8.encode('annon/base-payment/v2'), le(0, 1), bytes(id, 32))));
+/** The API accepts normalized identities; the wire always has one canonical encoding. */
+export function buildPurchaseMessage(p, assets) {
+    const id = purchaseId(p, assets);
+    const msg = JSON.stringify({
+        annon: 2,
+        refund: parseIdentity(p.refund),
+        purchase: {
+            network: p.network,
+            contract: p.contract,
+            route: p.route,
+            asset: p.asset,
+            file_id: p.file_id,
+            terms_hash: p.terms_hash,
+            price: p.price,
+            nonce: p.nonce,
+            buyer_key: p.buyer_key,
+            recovery: parseIdentity(p.recovery),
+            expires_at: p.expires_at,
+            purchase_id: id,
+        },
+    });
+    if (utf8.encode(msg).length > 1024)
+        throw new RangeError('purchase message exceeds 1024 UTF-8 bytes');
+    return msg;
+}
+/** Reads only the first 160 bytes, independently of an invalid/oversized purchase body. */
+export function parseRefundPrefix(msg) {
+    if (typeof msg !== 'string')
+        throw new TypeError('expected message string');
+    const prefix = msg.slice(0, 160);
+    const match = /^\{"annon":2,"refund":(\{"kind":"(?:evm|solana|near)","id":"[a-zA-Z0-9._-]+"\}),/.exec(prefix);
+    if (!match)
+        throw new TypeError('invalid refund prefix');
+    const encoded = match[1];
+    const id = parseIdentity(JSON.parse(encoded));
+    if (identityJson(id) !== encoded || utf8.encode(match[0]).length > 160)
+        throw new TypeError('noncanonical refund prefix');
+    return id;
+}
+/**
+ * Bounds work before JSON.parse, then compares with the canonical serializer. This also rejects
+ * duplicate/unknown fields at every level, alternate escapes, key order and whitespace.
+ */
+export function parsePurchaseMessage(msg, assets) {
+    if (typeof msg !== 'string' || msg.length > 1024 || utf8.encode(msg).length > 1024)
+        throw new RangeError('purchase message exceeds 1024 UTF-8 bytes');
+    const refund = parseRefundPrefix(msg);
+    const obj = JSON.parse(msg);
+    exactKeys(obj, ['annon', 'refund', 'purchase']);
+    if (obj.annon !== 2)
+        throw new TypeError('invalid annon version');
+    const p = obj.purchase;
+    exactKeys(p, [
+        'network',
+        'contract',
+        'route',
+        'asset',
+        'file_id',
+        'terms_hash',
+        'price',
+        'nonce',
+        'buyer_key',
+        'recovery',
+        'expires_at',
+        'purchase_id',
+    ]);
+    const decoded = {
+        version: 2,
+        refund,
+        network: p.network,
+        contract: p.contract,
+        route: p.route,
+        asset: p.asset,
+        file_id: p.file_id,
+        terms_hash: p.terms_hash,
+        price: p.price,
+        nonce: p.nonce,
+        buyer_key: p.buyer_key,
+        recovery: parseIdentity(p.recovery),
+        expires_at: p.expires_at,
+    };
+    if (buildPurchaseMessage(decoded, assets) !== msg)
+        throw new TypeError('noncanonical purchase message or incorrect purchase_id');
+    return decoded;
+}
+export function reopenTextV2(a) {
+    account(a.contract);
+    bytes(a.purchase_id, 32);
+    bytes(a.file_id, 32);
+    buyerKey(a.fresh_key);
+    bytes(a.nonce, 32);
+    return [
+        'Annon: open a purchased file again',
+        `contract: ${a.contract}`,
+        `purchase: ${a.purchase_id}`,
+        `file: ${a.file_id}`,
+        `recovery: ${identityText(a.recovery)}`,
+        `new key: ${a.fresh_key}`,
+        `nonce: ${a.nonce}`,
+        `valid until: ${utc(a.deadline)}`,
+    ].join('\n');
+}

package/dist/settle-near/terms.d.ts

@@ -0,0 +1,37 @@
+import { type Identity } from './identity.js';
+export declare const BASE_USDC = "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
+export declare const NEAR_USDC = "17208628f84f5d6ad33f0da3bbbeb27ffcb398eac501a31bd6ad2011e36133a1";
+export interface NearTerms {
+    token: string;
+    price: string;
+    recipients: {
+        identity: Identity;
+        bps: number;
+    }[];
+    remainder: number;
+}
+export interface BaseTerms {
+    usdc: string;
+    price: string;
+    pay_to: string;
+}
+export interface Terms {
+    network: string;
+    contract: string;
+    file_id: string;
+    seller: Identity;
+    pay2_version: 2;
+    cipher_hash: string;
+    moderator: string | null;
+    near: NearTerms;
+    base: BaseTerms | null;
+}
+/** Expected deployed assets; non-mainnet NEAR tokens have no implicit default. */
+export interface SettlementAssets {
+    nearUsdc?: string;
+    baseUsdc?: string;
+}
+export declare function encodeTerms(t: Terms, assets?: SettlementAssets): Uint8Array<ArrayBuffer>;
+export declare const termsHash: (t: Terms, assets?: SettlementAssets) => string;
+export declare function registerTextV2(t: Terms, sellerKey: string, deadline: number, assets?: SettlementAssets): string;
+export declare function publishTextV2(contract: string, fileId: string, headerHash: string): string;