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

package/dist/node/paths.js

@@ -0,0 +1,71 @@
+import { lstat, realpath } from 'node:fs/promises';
+import { basename, dirname, isAbsolute, relative, resolve } from 'node:path';
+import { AdapterError } from './errors.js';
+/** Canonical paths are passed to I/O; tool-relative paths start at the operator directory. */
+export async function confinePaths(input, workDir) {
+    if (!['sell', 'share', 'open', 'verify'].includes(input.command))
+        return input;
+    if (input.command === 'verify' && /^https?:/.test(input.target ?? ''))
+        return input;
+    try {
+        const root = await realpath(workDir);
+        const inside = (path) => {
+            const tail = relative(root, path);
+            if (tail === '..' ||
+                tail.startsWith(`..${process.platform === 'win32' ? '\\' : '/'}`) ||
+                isAbsolute(tail))
+                throw new Error();
+            return path;
+        };
+        const confined = async (value, output = false) => {
+            if (!value || value.includes('\0') || value.split(/[\\/]/).includes('..'))
+                throw new Error();
+            const path = resolve(root, value);
+            try {
+                return inside(await realpath(path));
+            }
+            catch (error) {
+                if (!output || error.code !== 'ENOENT')
+                    throw error;
+                // A dangling symlink is an existing entry, never a new output path.
+                const entry = await lstat(path).catch((error) => {
+                    if (error.code !== 'ENOENT')
+                        throw error;
+                    return null;
+                });
+                if (entry)
+                    throw new Error();
+                return inside(resolve(await realpath(dirname(path)), basename(path)));
+            }
+        };
+        const next = { ...input };
+        if (input.command === 'share') {
+            if (!input.target)
+                throw new Error();
+            next.target = await confined(input.target);
+        }
+        else if (input.command === 'sell') {
+            if (!input.target)
+                throw new Error();
+            next.target = await confined(input.target);
+            next.output = await confined(input.output ?? `${input.target}.pay2`, true);
+        }
+        else if (input.command === 'open') {
+            const isId = (value) => /^0x[0-9a-f]{64}$/.test(value);
+            if (input.target !== undefined && !isId(input.target))
+                next.target = await confined(input.target);
+            if (input.purchase !== undefined && !isId(input.purchase))
+                next.purchase = await confined(input.purchase);
+            if (input.output !== undefined)
+                next.output = await confined(input.output, true);
+            if (input.file !== undefined)
+                next.file = await confined(input.file);
+        }
+        else if (input.target !== undefined)
+            next.target = await confined(input.target);
+        return next;
+    }
+    catch {
+        throw new AdapterError('path_not_allowed', 'File paths must stay inside the configured workDir without parent traversal or symlink escape.', 2);
+    }
+}

package/dist/node/payment-terms.d.ts

@@ -0,0 +1,26 @@
+import type { Config } from '../near/rpc.js';
+import type { OneClickQuote } from '../oneclick/oneclick.js';
+import type { PaymentSummary, PurchaseRecord, SourceAsset, SourcePayment } from '../pay/purchase.js';
+import { type NearTerms } from '../settle-near/terms.js';
+type PaymentConfig = Pick<Config, 'network' | 'nearUsdc' | 'usdc'>;
+export declare function validatePaymentToken(t: {
+    network: string;
+    route: string;
+    token: string | undefined;
+}, config?: PaymentConfig): void;
+export type { SourceAsset, SourcePayment } from '../pay/purchase.js';
+/** Project only public facts from verified, encrypted purchase state, from required payment summaries. */
+export declare function savedPayment(record: PurchaseRecord, source?: SourcePayment | undefined): PaymentSummary;
+export declare function quotedSource(quote: OneClickQuote, asset: SourceAsset): SourcePayment;
+export declare function humanPaymentTerms(t: {
+    file: string;
+    resource: string;
+    network: string;
+    route: string;
+    token: string | undefined;
+    price: string;
+    recipients: NearTerms['recipients'];
+    remainder: number;
+    baseRecipient?: string | undefined;
+    source?: SourcePayment;
+}, config?: PaymentConfig): string;

package/dist/node/payment-terms.js

@@ -0,0 +1,127 @@
+import { usdc } from '../settle-near/codec.js';
+import { BASE_USDC, NEAR_USDC } from '../settle-near/terms.js';
+import { AdapterError } from './errors.js';
+export function validatePaymentToken(t, config) {
+    const deployment = config?.network ?? (t.route === 'base' ? 'near:mainnet' : t.network);
+    const expected = t.route === 'base' && t.network === 'eip155:8453'
+        ? (config?.usdc ?? (deployment === 'near:mainnet' ? BASE_USDC : undefined))
+        : (t.route === 'near' || t.route === '1click') && t.network === deployment
+            ? (config?.nearUsdc ?? (deployment === 'near:mainnet' ? NEAR_USDC : undefined))
+            : undefined;
+    const canonical = deployment === 'near:mainnet' ? (t.route === 'base' ? BASE_USDC : NEAR_USDC) : expected;
+    if (!['near:mainnet', 'near:testnet', 'near:sandbox'].includes(deployment) ||
+        !expected ||
+        t.token !== expected ||
+        t.token !== canonical)
+        throw new AdapterError('network_mismatch', 'Payment requires the canonical USDC token for this network.', 2);
+}
+/** Saved summaries are optional metadata. Discard a malformed source rather than fail a purchase. */
+function validSource(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const s = value;
+    const text = (value, max) => typeof value === 'string' && value.length > 0 && value.length <= max;
+    const identifier = (value, max = 128) => text(value, max) && /^[A-Za-z0-9._:-]+$/.test(value);
+    return (identifier(s.chain) &&
+        identifier(s.asset) &&
+        (s.symbol === undefined || identifier(s.symbol, 32)) &&
+        (s.contractAddress === undefined || identifier(s.contractAddress)) &&
+        text(s.amount, 39) &&
+        /^[1-9][0-9]*$/.test(s.amount) &&
+        BigInt(s.amount) < 2n ** 128n &&
+        (s.decimals === undefined ||
+            (typeof s.decimals === 'number' &&
+                Number.isInteger(s.decimals) &&
+                s.decimals >= 0 &&
+                s.decimals <= 255)) &&
+        (s.amountFormatted === undefined ||
+            (text(s.amountFormatted, 300) && /^(0|[1-9][0-9]*)(\.[0-9]+)?$/.test(s.amountFormatted))) &&
+        text(s.depositBefore, 64) &&
+        Number.isFinite(Date.parse(s.depositBefore)));
+}
+/** Project only public facts from verified, encrypted purchase state, from required payment summaries. */
+export function savedPayment(record, source = record.payment.source) {
+    const route = record.payment.route;
+    return {
+        amountUsdc: usdc(BigInt(record.terms.price)),
+        amountBaseUnits: record.terms.price,
+        asset: { symbol: 'USDC', id: record.terms.usdc },
+        network: record.terms.network,
+        route,
+        ...(route === '1click' && validSource(source)
+            ? {
+                source: {
+                    chain: source.chain,
+                    asset: source.asset,
+                    amount: source.amount,
+                    depositBefore: source.depositBefore,
+                    ...(source.symbol !== undefined ? { symbol: source.symbol } : {}),
+                    ...(source.decimals !== undefined ? { decimals: source.decimals } : {}),
+                    ...(source.contractAddress !== undefined
+                        ? { contractAddress: source.contractAddress }
+                        : {}),
+                    ...(source.amountFormatted !== undefined
+                        ? { amountFormatted: source.amountFormatted }
+                        : {}),
+                },
+            }
+            : {}),
+    };
+}
+export function quotedSource(quote, asset) {
+    const amount = quote.deposit.amount;
+    const decimals = asset.decimals;
+    const q = quote.response.quote;
+    let formatted;
+    if (decimals !== undefined) {
+        const digits = BigInt(amount)
+            .toString()
+            .padStart(decimals + 1, '0');
+        const fraction = decimals === 0 ? '' : digits.slice(-decimals).replace(/0+$/, '');
+        formatted =
+            (decimals === 0 ? digits : digits.slice(0, -decimals)) + (fraction ? `.${fraction}` : '');
+    }
+    else if (typeof q?.amountInFormatted === 'string' &&
+        /^(0|[1-9][0-9]*)(\.[0-9]+)?$/.test(q.amountInFormatted)) {
+        formatted = q.amountInFormatted;
+    }
+    return {
+        ...asset,
+        amount,
+        ...(formatted === undefined ? {} : { amountFormatted: formatted }),
+        depositBefore: quote.deposit.depositBefore,
+    };
+}
+export function humanPaymentTerms(t, config) {
+    validatePaymentToken(t, config);
+    const price = BigInt(t.price);
+    const amounts = t.recipients.map((r) => (price * BigInt(r.bps)) / 10000n);
+    const rest = price - amounts.reduce((sum, n) => sum + n, 0n);
+    amounts[t.remainder] = (amounts[t.remainder] ?? 0n) + rest;
+    const recipient = (i) => {
+        const r = t.recipients[i];
+        return r ? `${r.identity.kind}:${r.identity.id}` : '';
+    };
+    return [
+        `File: ${t.file}`,
+        `Resource: ${t.resource}`,
+        `Network: ${t.network}`,
+        `Route: ${t.route}`,
+        `Token: USDC on ${t.route === 'base' ? 'Base' : 'NEAR'} (${t.token})`,
+        `Price: ${usdc(price)} USDC`,
+        ...(t.source
+            ? [
+                `Source chain: ${t.source.chain === 'sol' ? 'Solana (sol)' : t.source.chain === 'eth' ? 'Ethereum (eth)' : t.source.chain}`,
+                `Source asset: ${t.source.symbol ?? t.source.asset}${t.source.contractAddress ? ` (${t.source.contractAddress})` : ''}`,
+                `Source asset ID: ${t.source.asset}`,
+                `Source amount: ${t.source.amountFormatted === undefined ? 'human units unavailable' : `${t.source.amountFormatted} ${t.source.symbol ?? 'tokens'}`} (${t.source.amount} base units)`,
+                `Deposit before: ${t.source.depositBefore}`,
+            ]
+            : []),
+        ...t.recipients.map((r, i) => `Recipient: ${recipient(i)} | ${r.bps / 100}% | ${usdc(amounts[i] ?? 0n)} USDC`),
+        `Rounding remainder: ${usdc(rest)} USDC to ${recipient(t.remainder)}`,
+        ...(t.route === 'base' && t.baseRecipient
+            ? [`Base payment recipient: ${t.baseRecipient}`]
+            : []),
+    ].join('\n');
+}

package/dist/node/purchase-commands.d.ts

@@ -0,0 +1,16 @@
+import type { CommandSession, RequestContext } from './command-context.js';
+/**
+ * `status`, first step: a purchase already accepted on chain, or the pending answer when no
+ * backup secret is configured. Returns nothing when the saved record has to be checked.
+ */
+declare function statusOnChain(ctx: RequestContext): Promise<Record<string, unknown> | undefined>;
+/** `status` from the saved purchase record: accepted, or still pending with a retry delay. */
+declare function status(ctx: CommandSession): Promise<Record<string, unknown>>;
+/** `recover`: purchases found for the recovery wallet, with per-purchase public errors. */
+declare function recover(ctx: CommandSession): Promise<Record<string, unknown>>;
+/**
+ * `open`: loads the purchase or recovery record, waits for acceptance, then claims the key and
+ * decrypts a local file or a download into the output. Unknown commands end here with usage.
+ */
+declare function open(ctx: CommandSession): Promise<Record<string, unknown>>;
+export { open, recover, status, statusOnChain };

package/dist/node/purchase-commands.js

@@ -0,0 +1,237 @@
+/** Buyer commands on an existing purchase: `status`, `recover` and `open`. */
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { download } from '../download/download.js';
+import { inspectHeader } from '../envelope/pay2.js';
+import { getPurchase } from '../near/rpc.js';
+import { encryptedPurchaseStore, encryptedRecoveryStore, importPurchase, importRecovery, } from '../pay/backup.js';
+import { purchaseKey } from '../pay/purchase.js';
+import { fileStore } from '../pay/store-node.js';
+import { bytes, hex } from '../settle-near/codec.js';
+import { backupPath, fail, isId } from './adapter-checks.js';
+import { AdapterError, publicError, usage } from './errors.js';
+import { fileSource, newOutput, withOutput, withSpool } from './io.js';
+import { resourceHeader } from './offers.js';
+import { resourceAllowed } from './resources.js';
+import { retryGate } from './retry-gate.js';
+import { readBackupSecret } from './wallets.js';
+/**
+ * `status`, first step: a purchase already accepted on chain, or the pending answer when no
+ * backup secret is configured. Returns nothing when the saved record has to be checked.
+ */
+async function statusOnChain(ctx) {
+    const { c, d, env, o, paymentDetails, pendingSetup } = ctx;
+    if (!o.target || !isId(o.target))
+        throw usage();
+    if (d.agent)
+        await retryGate({ ...c, purchaseId: o.target }).check();
+    const p = await (d.purchase ?? getPurchase)(c.nearRpc, c.contractId, o.target);
+    if (p)
+        return {
+            purchaseId: o.target,
+            state: 'accepted',
+            fileId: p.file_id,
+            grants: p.grants,
+            next: 'open',
+            ...(await paymentDetails(async () => encryptedPurchaseStore(fileStore(join(c.stateDir, 'records')), await readBackupSecret(o, env)).load(purchaseKey(o.target)))),
+        };
+    if (!o.backupSecretFile && !env.ANNON_BACKUP_SECRET_FILE && !env.ANNON_BACKUP_SECRET)
+        return pendingSetup(o.target);
+}
+/** `status` from the saved purchase record: accepted, or still pending with a retry delay. */
+async function status(ctx) {
+    const { c, d, env, o, paymentDetails, pendingSetup, sdk, wallet } = ctx;
+    if (!o.target)
+        throw usage();
+    let record;
+    try {
+        record = await sdk.store.load(purchaseKey(o.target));
+    }
+    catch {
+        return pendingSetup(o.target);
+    }
+    if (!record)
+        return pendingSetup(o.target);
+    if (o.wallet || env.ANNON_WALLET)
+        await wallet();
+    let accepted;
+    try {
+        accepted = await sdk.accept(record ?? undefined, o.target);
+    }
+    catch (error) {
+        const safe = publicError(error);
+        if (d.agent && safe.retryAfterSeconds !== undefined)
+            await retryGate({ ...c, purchaseId: o.target }).defer(safe.code, safe.retryAfterSeconds);
+        throw error;
+    }
+    if (d.agent && !accepted)
+        await retryGate({ ...c, purchaseId: o.target }).defer('settlement_pending', 30);
+    return {
+        purchaseId: o.target,
+        state: accepted ? 'accepted' : 'pending',
+        ...(await paymentDetails(async () => record)),
+        ...(accepted ? {} : { retryAfterSeconds: 30 }),
+        next: accepted
+            ? 'open'
+            : 'Check the payment and retry status. 1Click SUCCESS alone is not acceptance.',
+    };
+}
+/** `recover`: purchases found for the recovery wallet, with per-purchase public errors. */
+async function recover(ctx) {
+    const { c, o, sdk, wallet } = ctx;
+    if (!o.recovery || (o.purchase && !isId(o.purchase)))
+        throw usage();
+    const errors = [];
+    const recovered = await sdk.recover({
+        onError: (purchaseId, error) => {
+            const { code, message } = publicError(error);
+            errors.push({ purchaseId, code, message });
+        },
+        wallet: await wallet(),
+        ...(o.purchase ? { purchaseId: o.purchase } : {}),
+    });
+    return {
+        errors,
+        recovered: recovered.map((r) => ({
+            purchaseId: r.purchase_id,
+            fileId: r.file_id,
+            grant: r.grant,
+            backup: backupPath(c, r.id),
+        })),
+    };
+}
+/**
+ * `open`: loads the purchase or recovery record, waits for acceptance, then claims the key and
+ * decrypts a local file or a download into the output. Unknown commands end here with usage.
+ */
+async function open(ctx) {
+    const { c, d, env, fetcher, o, paymentDetails, rawStore, readListing, resources, sdk, secret, wallet, } = ctx;
+    if (o.command !== 'open' || !o.target || !o.output)
+        throw usage();
+    if (d.agent && o.url && !resourceAllowed(c.allowedResources, o.url))
+        return fail('resource_not_allowed', 'The resource URL is outside the configured policy.', 2);
+    await newOutput(o.output);
+    const ref = o.purchase ?? o.target;
+    let record;
+    let recovery;
+    if (isId(ref)) {
+        recovery =
+            (await encryptedRecoveryStore(rawStore, secret).load(`annon/recovery/${ref}`)) ?? undefined;
+        if (!recovery || recovery.grant === null)
+            record = (await sdk.store.load(purchaseKey(ref))) ?? undefined;
+    }
+    else {
+        const encrypted = await readFile(ref, 'utf8');
+        try {
+            record = await importPurchase(encrypted, secret);
+        }
+        catch {
+            recovery = await importRecovery(encrypted, secret);
+        }
+    }
+    if (!record && !recovery)
+        return fail('purchase_required', 'Provide a saved purchase ID or encrypted purchase/recovery backup.', 2);
+    if (record &&
+        (record.purchase.contract !== c.contractId || record.terms.contractId !== c.contractId))
+        throw new Error('backup contract mismatch');
+    const fileId = recovery?.file_id ?? record?.purchase.file_id;
+    if (!fileId)
+        throw usage();
+    if (o.wallet || env.ANNON_WALLET)
+        await wallet();
+    const purchaseId = recovery?.purchase_id ?? record?.id;
+    if (!purchaseId)
+        throw usage();
+    const resource = await resources.load(fileId);
+    const local = o.file ?? (o.purchase ? o.target : undefined);
+    const remoteUrl = o.url ?? resource?.url;
+    if (d.agent && !local && remoteUrl && !resourceAllowed(c.allowedResources, remoteUrl))
+        return fail('resource_not_allowed', 'The resource URL is outside the configured policy.', 2);
+    const settlementGate = retryGate({ ...c, purchaseId });
+    const downloadGate = !local && remoteUrl
+        ? retryGate({ ...c, purchaseId, fileId, host: new URL(remoteUrl).origin })
+        : undefined;
+    if (d.agent) {
+        await settlementGate.check();
+        await downloadGate?.check();
+    }
+    let accepted;
+    try {
+        accepted = await sdk.accept(record, purchaseId);
+    }
+    catch (error) {
+        const safe = publicError(error);
+        if (d.agent && safe.retryAfterSeconds !== undefined)
+            await settlementGate.defer(safe.code, safe.retryAfterSeconds);
+        throw error;
+    }
+    if (!accepted) {
+        if (d.agent)
+            await settlementGate.defer('settlement_pending', 30);
+        throw new AdapterError('settlement_pending', publicError({ code: 'settlement_pending' }).message, 4);
+    }
+    let readFileSource;
+    if (local) {
+        const source = await fileSource(local);
+        readFileSource = () => source;
+    }
+    else {
+        const url = o.url ?? resource?.url;
+        if (!url)
+            return fail('file_required', 'Provide --file or --url to open this saved purchase.', 2);
+        if (d.agent && !resourceAllowed(c.allowedResources, url))
+            return fail('resource_not_allowed', 'The resource URL is outside the configured policy.', 2);
+        const header = resource && resource.contractId === c.contractId
+            ? bytes(resource.header, (resource.header.length - 2) / 2)
+            : await resourceHeader(url, c, fetcher);
+        if (record &&
+            hex(await (await import('../envelope/pay2.js')).sha256(header)) !== record.checkedHeaderHash)
+            throw new Error('header mismatch');
+        const { listing } = await readListing(fileId);
+        await inspectHeader(header, listing, c.contractId);
+        const purchaseId = recovery?.purchase_id ?? record?.id;
+        const buyerSecret = recovery?.buyerSecret ?? record?.buyerSecret;
+        if (!purchaseId || !buyerSecret || recovery?.grant === null)
+            throw new Error('grant not final');
+        const payment = record?.purchase.route === 'base-usdc'
+            ? [...record.attempts].reverse().find((attempt) => attempt.payload)?.payload
+            : undefined;
+        readFileSource = () => download({
+            url,
+            contractId: c.contractId,
+            fileId,
+            header,
+            proof: {
+                secret: bytes(buyerSecret, 32),
+                purchase_id: purchaseId,
+                grant: recovery?.grant ?? 0,
+            },
+            fetch: fetcher,
+            ...(payment ? { payment: { header: payment } } : {}),
+        });
+    }
+    // claim_key is permissionless; a configured NEAR wallet can pay gas instead of a relayer.
+    if (o.wallet || env.ANNON_WALLET)
+        await wallet();
+    const opened = await withOutput(o.output, (sink) => sdk.openTo({
+        file: readFileSource(),
+        sink,
+        spool: (stream, use) => withSpool(o.output, stream, use),
+        ...(recovery?.grant != null ? { recovery } : record ? { record } : {}),
+    })).catch(async (error) => {
+        const safe = publicError(error);
+        if (d.agent &&
+            safe.retryAfterSeconds !== undefined &&
+            ['download_limited', 'download_in_progress', 'rate_limited', 'unavailable'].includes(safe.code))
+            await downloadGate?.defer(safe.code, safe.retryAfterSeconds);
+        throw error;
+    });
+    return {
+        fileId,
+        purchaseId: recovery?.purchase_id ?? record?.id,
+        output: o.output,
+        bytes: opened.meta.size,
+        ...(await paymentDetails(async () => record ?? (recovery ? sdk.store.load(purchaseKey(recovery.purchase_id)) : null))),
+    };
+}
+export { open, recover, status, statusOnChain };

package/dist/node/purchase-guard.d.ts

@@ -0,0 +1,19 @@
+import type { Store } from '../pay/store.js';
+export interface PurchaseGuard {
+    id: string;
+    revision: number;
+    owner: string | null;
+    until: number;
+    purchases: string[];
+}
+/** Reserve before confirmation and signing; checkpoints renew the in-progress claim. */
+export declare function claimPurchase(store: Store<PurchaseGuard>, key: string, o: {
+    known?: readonly string[];
+    force?: boolean;
+    now?: () => number;
+    live: (purchaseId: string, claimUntil: number) => Promise<boolean>;
+}): Promise<{
+    renew: () => Promise<void>;
+    saved: (purchaseId: string) => Promise<void>;
+    release: () => Promise<void>;
+}>;

package/dist/node/purchase-guard.js

@@ -0,0 +1,53 @@
+import { randomUUID } from 'node:crypto';
+import { AdapterError } from './errors.js';
+const refused = () => new AdapterError('purchase_open', 'A saved purchase already exists for this file. Resume it, or explicitly use --force for another purchase.', 2);
+/** Reserve before confirmation and signing; checkpoints renew the in-progress claim. */
+export async function claimPurchase(store, key, o) {
+    const now = o.now ?? (() => Math.floor(Date.now() / 1000));
+    const owner = randomUUID();
+    let held;
+    for (;;) {
+        const before = await store.load(key);
+        if (before?.owner && before.until > now())
+            throw refused();
+        const purchases = Array.from(new Set([...(before?.purchases ?? []), ...(o.known ?? [])]));
+        if (!o.force)
+            for (const id of purchases)
+                if (await o.live(id, before?.until ?? 0))
+                    throw refused();
+        const next = {
+            id: key,
+            revision: (before?.revision ?? -1) + 1,
+            owner,
+            until: now() + 120,
+            purchases,
+        };
+        if (await store.compareAndSet(key, before, next)) {
+            held = next;
+            break;
+        }
+    }
+    let queue = Promise.resolve();
+    const update = (patch) => {
+        const pending = queue.then(async () => {
+            const next = {
+                ...held,
+                revision: held.revision + 1,
+                ...patch(),
+            };
+            if (!(await store.compareAndSet(key, held, next)))
+                throw new AdapterError('store_conflict', 'The purchase reservation changed. Resume saved state.', 4);
+            held = next;
+        });
+        queue = pending.catch(() => { });
+        return pending;
+    };
+    return {
+        renew: () => update(() => ({ until: Math.max(held.until, now() + 120) })),
+        saved: (purchaseId) => update(() => ({
+            until: Math.max(held.until, now() + 120),
+            purchases: Array.from(new Set([...held.purchases, purchaseId])),
+        })),
+        release: () => update(() => ({ owner: null })),
+    };
+}

package/dist/node/relay-transport.d.ts

@@ -0,0 +1,6 @@
+import type { EncryptedRecord } from '../pay/backup.js';
+import type { Store } from '../pay/store.js';
+import type { AdapterSdk, RequestContext } from './command-context.js';
+/** The SDK for this run, wired to the relay transport and the relayer's sponsorship policy. */
+declare function createSdk(ctx: RequestContext, rawStore: Store<EncryptedRecord>, secret: Uint8Array): AdapterSdk;
+export { createSdk };