stellar-check 0.1.0

package/dist/check.js

@@ -0,0 +1,88 @@
+import { assessPayment } from './assess.js';
+import { isRecord, validateIntent } from './input.js';
+import { validateNetwork } from './state.js';
+/** Fresh observations on every call. An incomplete report may still contain known issues. */
+export async function checkPayment(input, provider) {
+    let capturedInput = input;
+    const startedAt = new Date().toISOString();
+    const unavailable = {
+        ok: false,
+        code: 'PROVIDER_UNAVAILABLE',
+        message: 'This read was not attempted because required input or network metadata was unavailable.',
+        observedAt: startedAt,
+    };
+    const snapshot = {
+        network: unavailable,
+        source: unavailable,
+        destination: unavailable,
+        memo: unavailable,
+    };
+    function finish() {
+        const report = assessPayment(capturedInput, snapshot);
+        report.observation = {
+            ...report.observation,
+            provider: provider.url,
+            startedAt,
+            finishedAt: new Date().toISOString(),
+        };
+        return report;
+    }
+    const validated = validateIntent(input);
+    if (!('payment' in validated))
+        return finish();
+    const payment = {
+        ...validated.payment,
+        asset: { ...validated.payment.asset },
+        ...(validated.payment.memo ? { memo: { ...validated.payment.memo } } : {}),
+    };
+    capturedInput = payment;
+    async function read(fn) {
+        try {
+            const result = await fn();
+            if (!isRecord(result) ||
+                typeof result.ok !== 'boolean' ||
+                typeof result.observedAt !== 'string' ||
+                (result.ok && !('value' in result)) ||
+                (!result.ok &&
+                    (![
+                        'PROVIDER_TIMEOUT',
+                        'PROVIDER_RATE_LIMITED',
+                        'PROVIDER_UNAVAILABLE',
+                        'MALFORMED_DATA',
+                    ].includes(String(result.code)) ||
+                        typeof result.message !== 'string')))
+                return {
+                    ok: false,
+                    code: 'MALFORMED_DATA',
+                    message: 'The provider returned a malformed observation.',
+                    observedAt: new Date().toISOString(),
+                };
+            return result;
+        }
+        catch {
+            return {
+                ok: false,
+                code: 'PROVIDER_UNAVAILABLE',
+                message: 'The provider failed to return an observation.',
+                observedAt: new Date().toISOString(),
+            };
+        }
+    }
+    snapshot.network = await read(() => provider.getNetwork());
+    if (!snapshot.network.ok)
+        return finish();
+    try {
+        validateNetwork(snapshot.network.value);
+    }
+    catch {
+        return finish();
+    }
+    if (snapshot.network.value.networkPassphrase !== payment.networkPassphrase)
+        return finish();
+    [snapshot.source, snapshot.destination, snapshot.memo] = await Promise.all([
+        read(() => provider.getAccount(payment.source)),
+        read(() => provider.getAccount(payment.destination)),
+        read(() => provider.checkMemo(payment)),
+    ]);
+    return finish();
+}

package/dist/horizon.d.ts

@@ -0,0 +1,17 @@
+import type { MemoCheck, NetworkState, PaymentIntent, PaymentProvider, Read } from './types.js';
+export interface HorizonOptions {
+    timeoutMs?: number;
+    fetch?: typeof fetch;
+    allowHttp?: boolean;
+}
+export declare class HorizonProvider implements PaymentProvider {
+    readonly url: string;
+    private readonly transport;
+    private readonly timeoutMs;
+    constructor(url: string, options?: HorizonOptions);
+    private request;
+    private capture;
+    getNetwork(): Promise<Read<NetworkState>>;
+    getAccount(address: string): Promise<Read<unknown | null>>;
+    checkMemo(payment: PaymentIntent): Promise<Read<MemoCheck>>;
+}

package/dist/horizon.js

@@ -0,0 +1,196 @@
+import { Account, AccountRequiresMemoError, Asset, Horizon, Operation, TransactionBuilder, } from '@stellar/stellar-sdk';
+import { formatAmount } from './amounts.js';
+import { isRecord, sdkMemo } from './input.js';
+class ProviderFailure extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+/** Restrict the SDK memo helper's account loading to our bounded read transport. */
+class MemoServer extends Horizon.Server {
+    load;
+    constructor(url, load) {
+        super(url, { allowHttp: new URL(url).protocol === 'http:' });
+        this.load = load;
+    }
+    loadAccount(address) {
+        return this.load(address);
+    }
+}
+export class HorizonProvider {
+    url;
+    transport;
+    timeoutMs;
+    constructor(url, options = {}) {
+        const parsed = new URL(url);
+        if (!['https:', 'http:'].includes(parsed.protocol) ||
+            parsed.username ||
+            parsed.password ||
+            parsed.search ||
+            parsed.hash)
+            throw new Error('Use a plain HTTP(S) Horizon URL without credentials, query or fragment.');
+        if (parsed.protocol === 'http:' && !options.allowHttp)
+            throw new Error('HTTP requires explicit allowHttp for local development.');
+        this.url = parsed.toString().replace(/\/$/, '');
+        this.transport = options.fetch ?? globalThis.fetch.bind(globalThis);
+        this.timeoutMs = options.timeoutMs ?? 10_000;
+        if (!Number.isSafeInteger(this.timeoutMs) || this.timeoutMs <= 0 || this.timeoutMs > 60_000)
+            throw new Error('timeoutMs must be an integer between 1 and 60000.');
+    }
+    async request(path, allowMissing = false) {
+        const controller = new AbortController();
+        let timer;
+        const timeout = new Promise((_, reject) => {
+            timer = setTimeout(() => {
+                reject(new ProviderFailure('PROVIDER_TIMEOUT', 'The Horizon read exceeded its time limit.'));
+                controller.abort();
+            }, this.timeoutMs);
+        });
+        try {
+            return await Promise.race([
+                timeout,
+                (async () => {
+                    const response = await this.transport(`${this.url}${path}`, {
+                        signal: controller.signal,
+                        headers: { Accept: 'application/json' },
+                        cache: 'no-store',
+                    });
+                    if (response.status === 404 && allowMissing)
+                        return { body: null };
+                    if (response.status === 429)
+                        throw new ProviderFailure('PROVIDER_RATE_LIMITED', 'Horizon rate-limited the read. Try again later.');
+                    if (!response.ok)
+                        throw new ProviderFailure('PROVIDER_UNAVAILABLE', `Horizon returned HTTP ${response.status}.`);
+                    let body;
+                    try {
+                        body = await response.json();
+                    }
+                    catch {
+                        throw new ProviderFailure('MALFORMED_DATA', 'Horizon returned invalid JSON.');
+                    }
+                    const header = response.headers.get('x-last-ledger');
+                    if (header !== null &&
+                        (!/^\d+$/.test(header) || !Number.isSafeInteger(Number(header)) || Number(header) <= 0))
+                        throw new ProviderFailure('MALFORMED_DATA', 'Horizon returned an invalid ledger header.');
+                    return header === null ? { body } : { body, ledger: Number(header) };
+                })(),
+            ]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async capture(fn) {
+        try {
+            return { ok: true, ...(await fn()), observedAt: new Date().toISOString() };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                code: error instanceof ProviderFailure ? error.code : 'PROVIDER_UNAVAILABLE',
+                message: error instanceof ProviderFailure
+                    ? error.message
+                    : 'The Horizon read could not be completed.',
+                observedAt: new Date().toISOString(),
+            };
+        }
+    }
+    getNetwork() {
+        return this.capture(async () => {
+            const root = await this.request('/');
+            if (!isRecord(root.body) ||
+                typeof root.body.network_passphrase !== 'string' ||
+                !root.body.network_passphrase.trim())
+                throw new ProviderFailure('MALFORMED_DATA', 'Horizon network passphrase is missing.');
+            const result = await this.request('/ledgers?order=desc&limit=1');
+            const embedded = isRecord(result.body) && result.body._embedded;
+            const records = isRecord(embedded) && embedded.records;
+            const ledger = Array.isArray(records) ? records[0] : undefined;
+            if (!isRecord(ledger) ||
+                typeof ledger.sequence !== 'number' ||
+                !Number.isSafeInteger(ledger.sequence) ||
+                ledger.sequence <= 0)
+                throw new ProviderFailure('MALFORMED_DATA', 'Horizon did not return a current ledger.');
+            function units(value) {
+                if ((typeof value !== 'number' && typeof value !== 'string') ||
+                    !/^\d{1,10}$/.test(String(value)))
+                    throw new ProviderFailure('MALFORMED_DATA', 'Ledger reserve or base fee is missing or malformed.');
+                const amount = BigInt(value);
+                if (amount <= 0n || amount > 4294967295n)
+                    throw new ProviderFailure('MALFORMED_DATA', 'Ledger reserve or base fee is outside its range.');
+                return formatAmount(amount);
+            }
+            return {
+                value: {
+                    networkPassphrase: root.body.network_passphrase,
+                    baseReserve: units(ledger.base_reserve_in_stroops),
+                    baseFee: units(ledger.base_fee_in_stroops),
+                    ledger: ledger.sequence,
+                },
+                ledger: ledger.sequence,
+            };
+        });
+    }
+    getAccount(address) {
+        return this.capture(async () => {
+            const { body, ...metadata } = await this.request(`/accounts/${encodeURIComponent(address)}`, true);
+            return { value: body, ...metadata };
+        });
+    }
+    checkMemo(payment) {
+        return this.capture(async () => {
+            let observedLedger;
+            let missing = false;
+            const server = new MemoServer(this.url, async (address) => {
+                const result = await this.request(`/accounts/${encodeURIComponent(address)}`, true);
+                observedLedger = result.ledger;
+                if (result.body === null) {
+                    missing = true;
+                    throw new ProviderFailure('PROVIDER_UNAVAILABLE', 'Memo destination is missing.');
+                }
+                const record = result.body;
+                // Horizon REST calls this `data`; the SDK exposes it as `data_attr`.
+                if (!isRecord(record) ||
+                    record.account_id !== address ||
+                    typeof record.sequence !== 'string' ||
+                    !/^\d+$/.test(record.sequence) ||
+                    !isRecord(record.data) ||
+                    Object.values(record.data).some((value) => typeof value !== 'string' ||
+                        !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value)))
+                    throw new ProviderFailure('MALFORMED_DATA', 'The account memo declaration data is missing or malformed.');
+                return new Horizon.AccountResponse({
+                    ...record,
+                    data_attr: record.data,
+                });
+            });
+            const asset = payment.asset.type === 'native'
+                ? Asset.native()
+                : new Asset(payment.asset.code, payment.asset.issuer);
+            // Sequence 0 is only a container for SDK memo inspection; never signed or submitted.
+            const builder = new TransactionBuilder(new Account(payment.source, '0'), {
+                fee: '100',
+                networkPassphrase: payment.networkPassphrase,
+            })
+                .addOperation(Operation.payment({ destination: payment.destination, asset, amount: payment.amount }))
+                .setTimeout(0);
+            if (payment.memo)
+                builder.addMemo(sdkMemo(payment.memo));
+            let result = payment.memo ? 'present' : 'not_required';
+            try {
+                await server.checkMemoRequired(builder.build());
+            }
+            catch (error) {
+                if (error instanceof AccountRequiresMemoError)
+                    result = 'required';
+                else if (!missing)
+                    throw error;
+            }
+            return {
+                value: { result },
+                ...(observedLedger === undefined ? {} : { ledger: observedLedger }),
+            };
+        });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { checkPayment } from './check.js';
+export { assessPayment } from './assess.js';
+export { HorizonProvider } from './horizon.js';
+export type { HorizonOptions } from './horizon.js';
+export type * from './types.js';
+export { importPaymentXdr } from './xdr.js';
+export type { XdrImportResult } from './xdr.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export { checkPayment } from './check.js';
+export { assessPayment } from './assess.js';
+export { HorizonProvider } from './horizon.js';
+export { importPaymentXdr } from './xdr.js';

package/dist/input.d.ts

@@ -0,0 +1,10 @@
+import { Memo } from '@stellar/stellar-sdk';
+import type { Diagnostic, PaymentIntent, PaymentMemo } from './types.js';
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function sdkMemo(memo: PaymentMemo): Memo;
+export declare function validateIntent(value: unknown): {
+    payment: PaymentIntent;
+    issues: [];
+} | {
+    issues: Diagnostic[];
+};

package/dist/input.js

@@ -0,0 +1,102 @@
+import { Memo, StrKey } from '@stellar/stellar-sdk';
+import { parseAmount } from './amounts.js';
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function sdkMemo(memo) {
+    switch (memo.type) {
+        case 'text':
+            return Memo.text(memo.value);
+        case 'id':
+            return Memo.id(memo.value);
+        case 'hash':
+            return Memo.hash(memo.value);
+        case 'return':
+            return Memo.return(memo.value);
+    }
+}
+export function validateIntent(value) {
+    const fail = (unsupported, message) => ({
+        issues: [
+            {
+                code: unsupported ? 'UNSUPPORTED_PAYMENT' : 'INVALID_INPUT',
+                party: 'application',
+                message,
+                action: unsupported
+                    ? 'Use one classic payment between distinct G accounts, with one source and fee payer.'
+                    : 'Correct the payment input and check again.',
+            },
+        ],
+    });
+    if (!isRecord(value))
+        return fail(false, 'Payment must be an object.');
+    const allowed = new Set([
+        'networkPassphrase',
+        'source',
+        'destination',
+        'asset',
+        'amount',
+        'feeBudget',
+        'memo',
+        'operationType',
+        'operationSource',
+        'feePayer',
+    ]);
+    if (Object.keys(value).some((key) => !allowed.has(key)))
+        return fail(true, 'This payment includes unsupported fields or transaction features.');
+    if (value.operationType !== undefined && value.operationType !== 'payment')
+        return fail(true, 'Only a classic payment is supported.');
+    if (typeof value.source !== 'string' || typeof value.destination !== 'string')
+        return fail(false, 'Source and destination must be public G addresses.');
+    if (!value.source.startsWith('G') ||
+        !value.destination.startsWith('G') ||
+        value.source === value.destination)
+        return fail(true, 'Only distinct ordinary G-address accounts are supported.');
+    if (!StrKey.isValidEd25519PublicKey(value.source) ||
+        !StrKey.isValidEd25519PublicKey(value.destination))
+        return fail(false, 'Source or destination has an invalid address checksum.');
+    if ((value.feePayer !== undefined && value.feePayer !== value.source) ||
+        (value.operationSource !== undefined && value.operationSource !== value.source))
+        return fail(true, 'Separate operation sources and fee payers are unsupported.');
+    if (typeof value.networkPassphrase !== 'string' || !value.networkPassphrase.trim())
+        return fail(false, 'Choose an explicit network passphrase.');
+    if (!isRecord(value.asset) || !['native', 'credit'].includes(String(value.asset.type)))
+        return fail(true, 'Only native XLM or a classic issued asset is supported.');
+    const asset = value.asset;
+    if (asset.type === 'native' && Object.keys(asset).some((key) => key !== 'type'))
+        return fail(false, 'Native XLM must not specify a code or issuer.');
+    if (asset.type === 'credit') {
+        if (Object.keys(asset).some((key) => !['type', 'code', 'issuer'].includes(key)))
+            return fail(true, 'Unsupported asset fields.');
+        if (typeof asset.code !== 'string' ||
+            !/^[a-zA-Z0-9]{1,12}$/.test(asset.code) ||
+            typeof asset.issuer !== 'string' ||
+            !StrKey.isValidEd25519PublicKey(asset.issuer))
+            return fail(false, 'Issued assets require a 1–12 character alphanumeric code and valid G-address issuer.');
+        if (asset.issuer === value.source || asset.issuer === value.destination)
+            return fail(true, 'Payments involving the asset issuer as a party are unsupported.');
+    }
+    try {
+        if (parseAmount(value.amount) === 0n)
+            return fail(false, 'Payment amount must be greater than zero.');
+        if (parseAmount(value.feeBudget, 4294967295n) === 0n)
+            return fail(false, 'Fee budget must be positive and within the transaction fee range.');
+        if (value.memo !== undefined) {
+            if (!isRecord(value.memo) ||
+                Object.keys(value.memo).some((k) => !['type', 'value'].includes(k)) ||
+                !['text', 'id', 'hash', 'return'].includes(String(value.memo.type)) ||
+                typeof value.memo.value !== 'string')
+                return fail(false, 'Use a text, ID, hash or return-hash memo.');
+            if (value.memo.type === 'id' && !/^\d{1,20}$/.test(value.memo.value))
+                return fail(false, 'Memo ID must be an unsigned integer string.');
+            if (['hash', 'return'].includes(String(value.memo.type)) &&
+                !/^[0-9a-fA-F]{64}$/.test(value.memo.value))
+                return fail(false, 'Hash memos must contain 64 hexadecimal characters.');
+            sdkMemo(value.memo);
+        }
+    }
+    catch (error) {
+        return fail(false, error instanceof Error ? error.message : 'Invalid amount or memo.');
+    }
+    return { payment: value, issues: [] };
+}

package/dist/state.d.ts

@@ -0,0 +1,20 @@
+import type { Asset, NetworkState } from './types.js';
+export interface Balance {
+    balance: bigint;
+    selling: bigint;
+    buying: bigint;
+    limit: bigint;
+    authorized: boolean;
+}
+export interface AccountState {
+    reserveUnits: bigint;
+    native: Balance;
+    asset?: Balance;
+    lastModifiedLedger: number;
+}
+export declare function validateNetwork(value: NetworkState): {
+    reserve: bigint;
+    fee: bigint;
+};
+/** Validate relevant entries; unrelated pool-share entries never substitute for a trustline. */
+export declare function parseAccount(value: unknown, address: string, asset: Asset): AccountState;

package/dist/state.js

@@ -0,0 +1,88 @@
+import { StrKey } from '@stellar/stellar-sdk';
+import { MAX_AMOUNT, parseAmount } from './amounts.js';
+import { isRecord } from './input.js';
+function count(value) {
+    if (typeof value !== 'number' ||
+        !Number.isSafeInteger(value) ||
+        value < 0 ||
+        value > 4_294_967_295)
+        throw new Error('Missing or invalid account counter/ledger.');
+    return value;
+}
+export function validateNetwork(value) {
+    if (!isRecord(value) ||
+        typeof value.networkPassphrase !== 'string' ||
+        !value.networkPassphrase.trim() ||
+        count(value.ledger) === 0)
+        throw new Error('Missing network identity or ledger.');
+    const reserve = parseAmount(value.baseReserve, 4294967295n), fee = parseAmount(value.baseFee, 4294967295n);
+    if (reserve === 0n || fee === 0n)
+        throw new Error('Base reserve and base fee must be positive.');
+    return { reserve, fee };
+}
+/** Validate relevant entries; unrelated pool-share entries never substitute for a trustline. */
+export function parseAccount(value, address, asset) {
+    if (!isRecord(value) || value.account_id !== address || !Array.isArray(value.balances))
+        throw new Error('Account identity or balances are missing or inconsistent.');
+    const subentries = count(value.subentry_count), sponsoring = count(value.num_sponsoring), sponsored = count(value.num_sponsored);
+    if (sponsored > 2 + subentries)
+        throw new Error('Sponsored reserves exceed this account’s reserve entries.');
+    const reserveUnits = BigInt(2 + subentries + sponsoring - sponsored);
+    const entries = new Map();
+    for (const entry of value.balances) {
+        if (!isRecord(entry) || typeof entry.asset_type !== 'string')
+            throw new Error('Malformed balance entry.');
+        let key;
+        if (entry.asset_type === 'native')
+            key = 'native';
+        else if (entry.asset_type === 'liquidity_pool_shares') {
+            if (typeof entry.liquidity_pool_id !== 'string' ||
+                !/^[0-9a-f]{64}$/.test(entry.liquidity_pool_id))
+                throw new Error('Malformed pool-share identity.');
+            key = `pool:${entry.liquidity_pool_id}`;
+        }
+        else if (['credit_alphanum4', 'credit_alphanum12'].includes(entry.asset_type)) {
+            if (typeof entry.asset_code !== 'string' ||
+                !/^[a-zA-Z0-9]{1,12}$/.test(entry.asset_code) ||
+                typeof entry.asset_issuer !== 'string' ||
+                !StrKey.isValidEd25519PublicKey(entry.asset_issuer))
+                throw new Error('Malformed trustline asset identity.');
+            if (entry.asset_code.length <= 4 !== (entry.asset_type === 'credit_alphanum4'))
+                throw new Error('Asset code length does not match its type.');
+            key = `${entry.asset_code}:${entry.asset_issuer}`;
+        }
+        else
+            throw new Error('Unknown balance entry type.');
+        if (entries.has(key))
+            throw new Error('Duplicate balance entry.');
+        entries.set(key, entry);
+    }
+    if (entries.size - (entries.has('native') ? 1 : 0) > subentries)
+        throw new Error('Subentry count omits returned trustlines or pool shares.');
+    function balance(entry, native) {
+        if (!entry)
+            throw new Error('Native balance is missing.');
+        const amount = parseAmount(entry.balance), selling = parseAmount(entry.selling_liabilities), buying = parseAmount(entry.buying_liabilities);
+        const limit = native ? MAX_AMOUNT : parseAmount(entry.limit);
+        if (selling > amount || amount > limit || buying > limit - amount)
+            throw new Error('Balance, liabilities and limit are inconsistent.');
+        if (!native && typeof entry.is_authorized !== 'boolean')
+            throw new Error('Trustline authorization is missing.');
+        return {
+            balance: amount,
+            selling,
+            buying,
+            limit,
+            authorized: native || entry.is_authorized === true,
+        };
+    }
+    const result = {
+        reserveUnits,
+        native: balance(entries.get('native'), true),
+        lastModifiedLedger: count(value.last_modified_ledger),
+    };
+    const relevant = asset.type === 'credit' ? entries.get(`${asset.code}:${asset.issuer}`) : undefined;
+    if (relevant)
+        result.asset = balance(relevant, false);
+    return result;
+}

package/dist/types.d.ts

@@ -0,0 +1,108 @@
+export type Asset = {
+    type: 'native';
+} | {
+    type: 'credit';
+    code: string;
+    issuer: string;
+};
+export type PaymentMemo = {
+    type: 'text' | 'id' | 'hash' | 'return';
+    value: string;
+};
+/** Decimal strings use XLM/asset units, including feeBudget (not stroops). */
+export interface PaymentIntent {
+    networkPassphrase: string;
+    source: string;
+    destination: string;
+    asset: Asset;
+    amount: string;
+    feeBudget: string;
+    memo?: PaymentMemo;
+    operationType?: 'payment';
+    operationSource?: string;
+    feePayer?: string;
+}
+export type DiagnosticCode = 'INVALID_INPUT' | 'UNSUPPORTED_PAYMENT' | 'NETWORK_MISMATCH' | 'PROVIDER_TIMEOUT' | 'PROVIDER_RATE_LIMITED' | 'PROVIDER_UNAVAILABLE' | 'MALFORMED_DATA' | 'SOURCE_ACCOUNT_MISSING' | 'DESTINATION_ACCOUNT_MISSING' | 'SOURCE_TRUSTLINE_MISSING' | 'DESTINATION_TRUSTLINE_MISSING' | 'SOURCE_NOT_AUTHORIZED' | 'DESTINATION_NOT_AUTHORIZED' | 'INSUFFICIENT_XLM' | 'INSUFFICIENT_ASSET' | 'DESTINATION_CAPACITY_EXCEEDED' | 'FEE_BUDGET_TOO_LOW' | 'MEMO_REQUIRED';
+export type Party = 'sender' | 'recipient' | 'issuer' | 'application' | 'provider';
+export interface Diagnostic {
+    code: DiagnosticCode;
+    party: Party;
+    message: string;
+    action: string;
+}
+export type ProviderErrorCode = 'PROVIDER_TIMEOUT' | 'PROVIDER_RATE_LIMITED' | 'PROVIDER_UNAVAILABLE' | 'MALFORMED_DATA';
+export type Read<T> = {
+    ok: true;
+    value: T;
+    observedAt: string;
+    ledger?: number;
+} | {
+    ok: false;
+    code: ProviderErrorCode;
+    message: string;
+    observedAt: string;
+};
+export interface NetworkState {
+    networkPassphrase: string;
+    baseReserve: string;
+    baseFee: string;
+    ledger: number;
+}
+export interface MemoCheck {
+    result: 'required' | 'present' | 'not_required';
+}
+export interface Snapshot {
+    network: Read<NetworkState>;
+    source: Read<unknown | null>;
+    destination: Read<unknown | null>;
+    memo: Read<MemoCheck>;
+}
+export interface PaymentProvider {
+    readonly url: string;
+    getNetwork(): Promise<Read<NetworkState>>;
+    getAccount(address: string): Promise<Read<unknown | null>>;
+    checkMemo(payment: PaymentIntent): Promise<Read<MemoCheck>>;
+}
+export type Check = 'input' | 'network' | 'source_account' | 'destination_account' | 'source_xlm' | 'source_asset' | 'destination_capacity' | 'memo';
+export interface Coverage {
+    check: Check;
+    status: 'complete' | 'unresolved' | 'not_applicable';
+    reason?: string;
+}
+export interface Facts {
+    baseReserve?: string;
+    baseFee?: string;
+    sourceReserve?: string;
+    sourceXlmBalance?: string;
+    nativeSellingLiabilities?: string;
+    feeBudget?: string;
+    availableXlm?: string;
+    requiredXlm?: string;
+    xlmShortfall?: string;
+    availableAsset?: string;
+    assetShortfall?: string;
+    receivingCapacity?: string;
+    capacityShortfall?: string;
+    memo?: 'required' | 'presence_only' | 'not_required';
+}
+export interface Report {
+    status: 'no_known_issues' | 'issues_found' | 'incomplete';
+    issues: Diagnostic[];
+    facts: Facts;
+    coverage: Coverage[];
+    observation: {
+        networkPassphrase: string | null;
+        provider?: string;
+        startedAt?: string;
+        finishedAt?: string;
+        reads: {
+            check: keyof Snapshot;
+            observedAt: string;
+            ledger?: number;
+        }[];
+        sourceLastModifiedLedger?: number;
+        destinationLastModifiedLedger?: number;
+        atomic: false;
+    };
+    limitations: string[];
+}

package/dist/types.js

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

package/dist/xdr.d.ts

@@ -0,0 +1,19 @@
+import type { PaymentIntent } from './types.js';
+export type XdrImportResult = {
+    ok: true;
+    payment: PaymentIntent;
+    context: {
+        sequence: string;
+        timeBounds?: {
+            minTime: string;
+            maxTime: string;
+        };
+        limitations: string[];
+    };
+} | {
+    ok: false;
+    code: 'INVALID_XDR' | 'UNSUPPORTED_XDR';
+    message: string;
+};
+/** Decode locally. This extracts a payment intent; it does not validate a transaction. */
+export declare function importPaymentXdr(input: unknown, networkPassphrase: string): XdrImportResult;