crypto-aio 0.0.2 → 0.1.0

package/dist/core/blockchain/handle.js

@@ -0,0 +1,579 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Blockchain = void 0;
+const resolve_1 = require("../config/resolve");
+const internals_1 = require("../container/internals");
+const error_1 = require("../errors/error");
+const address_1 = require("../model/address");
+const amount_1 = require("../model/amount");
+const intent_1 = require("../model/intent");
+const engine_1 = require("../lifecycle/engine");
+const intent_2 = require("../lifecycle/intent");
+const monitor_1 = require("../lifecycle/monitor");
+const observations_1 = require("../lifecycle/observations");
+const views_1 = require("../lifecycle/views");
+const scanner_1 = require("../observe/scanner");
+const hd_1 = require("../signing/hd");
+const wallet_1 = require("../signing/wallet");
+const bytes_1 = require("../util/bytes");
+const names_1 = require("../util/names");
+const default_ref_1 = require("./default-ref");
+const internal_1 = require("./internal");
+const mapping_1 = require("./mapping");
+/** Immutable handle bound to one chain, network, library, provider set and wallet. */
+class Blockchain {
+    /** @internal Use `CryptoAio#blockchain` or `Blockchain.create`. */
+    constructor(internals) {
+        (0, internal_1.bindInternals)(this, internals);
+        Object.freeze(this);
+    }
+    /** Creates a handle on the default container (see `configure`). */
+    static create(config) {
+        return (0, default_ref_1.defaultBlockchain)(config);
+    }
+    get chain() {
+        return (0, internal_1.internalsOf)(this).selection.chain.id;
+    }
+    get network() {
+        return (0, internal_1.internalsOf)(this).selection.network.id;
+    }
+    get library() {
+        return (0, internal_1.internalsOf)(this).selection.library;
+    }
+    /** Frozen, redacted snapshot of the resolved configuration. */
+    get config() {
+        return (0, resolve_1.describeSelection)((0, internal_1.internalsOf)(this).selection);
+    }
+    /** A fresh copy on every read; mutating the result never affects `supports()`. */
+    get capabilities() {
+        return new Set((0, internal_1.internalsOf)(this).selection.capabilities);
+    }
+    supports(capability) {
+        return (0, internal_1.internalsOf)(this).selection.capabilities.has(capability);
+    }
+    /** Returns a NEW handle; this handle and operations started from it are unaffected. */
+    with(overrides) {
+        const { selection, container } = (0, internal_1.internalsOf)(this);
+        return container.blockchain({
+            ...selection.handle,
+            ...overrides,
+            chain: this.chain,
+        });
+    }
+    /**
+     * Loads the adapter, connects its transport and validates it's actually usable; fails fast
+     * on a missing dependency (`DEPENDENCY_MISSING`), an invalid wallet (surfaced by resolving
+     * it), or a provider that can't serve reads: `PROVIDER_UNAVAILABLE` when no configured
+     * endpoint is usable, `PROVIDER_MISCONFIGURED` (non-retryable) when every endpoint's
+     * identity mismatches the configured network. An endpoint is usable when it's 'healthy',
+     * 'lagging' or 'half-open' (the breaker is willing to try it), or 'unknown' while the
+     * transport has no health probes configured at all — nothing could ever have marked it
+     * healthy/lagging in that case, so 'unknown' is simply its steady state.
+     */
+    async ready() {
+        const internals = (0, internal_1.internalsOf)(this);
+        const pooled = await internals.pooled();
+        await pooled.transport.refreshHealth();
+        const statuses = pooled.transport.status();
+        if (statuses.length > 0 && statuses.every((s) => s.state === 'disabled')) {
+            throw new error_1.ProviderError('PROVIDER_MISCONFIGURED', `every endpoint for ${this.chain} serves a different network than configured`, { retryable: false });
+        }
+        const usable = (state) => state === 'healthy' ||
+            state === 'lagging' ||
+            state === 'half-open' ||
+            (state === 'unknown' && !pooled.transport.hasProbes());
+        if (!statuses.some((s) => usable(s.state))) {
+            throw new error_1.ProviderError('PROVIDER_UNAVAILABLE', `no healthy endpoint for ${this.chain}`);
+        }
+        if (internals.selection.wallet)
+            await internals.wallet();
+        return this;
+    }
+    async limits() {
+        const { driver } = await (0, internal_1.internalsOf)(this).pooled();
+        const wallet = (0, internal_1.internalsOf)(this).selection.wallet;
+        const options = wallet ? (0, wallet_1.walletOptionsOf)(wallet.config) : {};
+        return (driver.limits?.(options) ?? {
+            maxOutputs: this.supports('batch-transfer') ? Number.MAX_SAFE_INTEGER : 1,
+        });
+    }
+    async validateAddress(address) {
+        return (await this.mapping()).driver.address.validate(address);
+    }
+    async normalizeAddress(address) {
+        return (0, mapping_1.toAddress)(await this.mapping(), address);
+    }
+    /** The chain's address for `publicKey`. `options.hd` is reserved: the core builds it
+     * from a wallet's `xpub`, so a caller's `hd` is dropped and never reaches the driver.
+     * `null` options (from an untyped caller) are none. */
+    async addressFromPublicKey(publicKey, options = {}) {
+        const { hd: _reserved, ...callerOptions } = options ?? {};
+        const bytes = typeof publicKey === 'string' ? (0, bytes_1.fromHex)(publicKey) : publicKey;
+        return this.driverAddress(bytes, callerOptions);
+    }
+    /** Address of the handle's own selected wallet, or of another configured `wallet` by name
+     * — resolved fresh against this handle's driver, without switching the handle.
+     * Re-resolved through `resolveSelection` (not `resolveWallet` directly) so a
+     * named wallet gets the same `wallet.chains` enablement check, unknown-signer validation and
+     * signer-scheme compatibility check that the handle's own wallet got at construction. */
+    async walletAddress(wallet) {
+        const internals = (0, internal_1.internalsOf)(this);
+        const selection = internals.selection;
+        if (wallet === undefined || wallet === selection.wallet?.name) {
+            return (await internals.wallet()).address;
+        }
+        const container = (0, internals_1.containerOf)(internals.container);
+        const effective = container.effective();
+        // An own-property check, so a wallet literally named 'constructor' (or any other
+        // Object.prototype key) can never be mistaken for one that exists.
+        if (!Object.hasOwn(effective.wallets, wallet)) {
+            throw new error_1.ConfigError('CONFIG_INVALID', (0, names_1.unknownName)('wallet', Object.keys(effective.wallets)));
+        }
+        const { driver } = await internals.pooled();
+        const resolved = (0, resolve_1.resolveSelection)({
+            handle: { ...selection.handle, wallet, signer: undefined },
+            effective,
+            catalogs: container.runtime.catalogs,
+        });
+        const resolvedWallet = await (0, wallet_1.resolveWallet)(resolved, driver, effective.signers, container.runtime.catalogs.schemes, container.signerDeadline());
+        return resolvedWallet.address;
+    }
+    /** Derives a deposit address from the wallet's xpub (capability `hd-public-derivation`). */
+    async deriveAddress(wallet, index) {
+        if (!this.supports('hd-public-derivation')) {
+            throw new error_1.UnsupportedCapabilityError('UNSUPPORTED_CAPABILITY', `${this.chain} does not support public derivation`);
+        }
+        if (!Number.isInteger(index) || index < 0 || index >= 2 ** 31) {
+            throw new error_1.ValidationError('INVALID_INTENT', 'derivation index must be an integer in [0, 2^31)');
+        }
+        const internals = (0, internal_1.internalsOf)(this);
+        const { wallets } = (0, internals_1.containerOf)(internals.container).effective();
+        // Own keys only, so `toString` is no wallet. The caller's text is never repeated: it
+        // may be a pasted secret.
+        if (!Object.hasOwn(wallets, wallet)) {
+            throw new error_1.ConfigError('CONFIG_INVALID', (0, names_1.unknownName)('wallet', Object.keys(wallets)));
+        }
+        const config = wallets[wallet];
+        if (!config?.xpub)
+            throw new error_1.ConfigError('CONFIG_INVALID', `wallet '${wallet}' has no xpub`);
+        // A non-string xpubPath is CONFIG_INVALID, as at wallet resolution.
+        const path = ((0, wallet_1.xpubPathOf)(config) ?? '0/{index}').replace('{index}', String(index));
+        // A UTXO chain's extended keys carry its network class; account-model
+        // wallets (EVM, Tron) export `xpub` on every network, so theirs is not checked. A chain
+        // whose wallets do the same says so (`xpubNetworkClass: false`, Avalanche X/P).
+        const { chain, network } = internals.selection;
+        const classed = chain.xpubNetworkClass ?? chain.model === 'utxo';
+        const publicKey = (0, hd_1.deriveXpubChild)(config.xpub, path, config.xpubVersions, classed ? { testnet: network.testnet } : undefined);
+        // The core's own options, with the wallet's `hd`, reach the driver directly.
+        return this.driverAddress(publicKey, (0, wallet_1.walletOptionsOf)(config));
+    }
+    async resolveAsset(asset) {
+        const m = await this.mapping();
+        return m.assets.resolve(m.selection, m.driver, asset);
+    }
+    async getBalance(address, asset) {
+        const m = await this.mapping();
+        const target = (0, mapping_1.toAddress)(m, address);
+        const info = await m.assets.resolve(m.selection, m.driver, asset);
+        const base = await m.driver.reader.getBalance(target.canonical, info.ref);
+        return { address: target, asset: info, amount: amount_1.Amount.fromBase(base, info) };
+    }
+    async getBalances(address, assets) {
+        return Promise.all(assets.map((asset) => this.getBalance(address, asset)));
+    }
+    async estimateFee(intent) {
+        const m = await this.mapping();
+        const internals = (0, internal_1.internalsOf)(this);
+        const wallet = internals.selection.wallet ? await internals.wallet() : undefined;
+        const from = intent.from !== undefined ? (0, mapping_1.toAddress)(m, intent.from) : wallet?.address;
+        if (!from)
+            throw new error_1.ValidationError('INVALID_INTENT', 'estimateFee needs a wallet or intent.from');
+        const normalized = await (0, intent_2.normalizeIntent)(m, intent, from);
+        const draft = await m.driver.builder.estimateFee((0, intent_1.toStoredIntent)(normalized), {
+            from: from.canonical,
+            keys: wallet?.keys ?? [],
+            wallet: wallet?.options ?? {},
+        });
+        return (0, mapping_1.toFeeEstimate)(m, draft);
+    }
+    async getTransaction(id) {
+        const m = await this.mapping();
+        const tx = await m.driver.reader.getTransaction(id);
+        if (!tx)
+            return null;
+        const [head, finalized] = await Promise.all([
+            m.driver.reader.getBlockHeight(),
+            m.driver.reader.getFinalizedHeight(),
+        ]);
+        return (0, mapping_1.toTransaction)(m, tx, head, finalized);
+    }
+    /** Status of a managed Operation (by id, Attempt ref or tx hash) or of any transaction id. */
+    async getTransactionStatus(id) {
+        return (await this.monitor().status(await this.readTarget(), id)).status;
+    }
+    /**
+     * Resolves once `confirmations` (default: the handle's) are reached. With
+     * `finality: 'final'`, a managed Operation (by id, Attempt ref or tx hash) resolves on
+     * **proven** finality (finalized data confirmed by quorum proof reads); a transaction the
+     * library does not manage resolves on **observed** finality (one endpoint's view of a
+     * block at or below the finalized height). Rejects with the chain error when the
+     * Operation fails, expires or is replaced (`TX_REVERTED` for an unmanaged transaction
+     * that reverted), with `TIMEOUT` (retryable, state unchanged) when time runs out, and
+     * with the reason of an aborted `signal`.
+     */
+    async waitForConfirmation(ref, options = {}) {
+        const { status, record } = await this.monitor().waitFor(await this.readTarget(), ref, options);
+        return { status, ...(record ? { operation: await this.view(record) } : {}) };
+    }
+    /** Yields each status change until the Operation is terminal (or the transaction is final). */
+    watch(ref, options = {}) {
+        const readTarget = () => this.readTarget();
+        const monitor = () => this.monitor();
+        const view = (record) => this.view(record);
+        return {
+            async *[Symbol.asyncIterator]() {
+                const target = await readTarget();
+                for await (const snapshot of monitor().watch(target, ref, options)) {
+                    yield {
+                        status: snapshot.status,
+                        ...(snapshot.record ? { operation: await view(snapshot.record) } : {}),
+                    };
+                }
+            },
+        };
+    }
+    async getBlockHeight() {
+        return (await this.mapping()).driver.reader.getBlockHeight();
+    }
+    async getBlock(ref) {
+        const block = await (await this.mapping()).driver.reader.getBlock(ref);
+        return block ? (0, mapping_1.toBlock)(block) : null;
+    }
+    /**
+     * Reorg-aware, at-least-once block scanner (capability `block-scan`): `ack()` each event
+     * to commit the cursor before asking for the next. Invalid options throw `CONFIG_INVALID`.
+     */
+    scanner(options) {
+        if (!this.supports('block-scan')) {
+            throw new error_1.UnsupportedCapabilityError('UNSUPPORTED_CAPABILITY', `${this.chain} does not support block scanning`);
+        }
+        const internals = (0, internal_1.internalsOf)(this);
+        const container = (0, internals_1.containerOf)(internals.container);
+        const { runtime } = container;
+        return new scanner_1.Scanner({
+            load: async () => {
+                // One pooled entry, so the driver and its transport always belong together.
+                const { driver, transport } = await internals.pooled();
+                const blocks = driver.blocks;
+                if (!blocks)
+                    throw new error_1.UnsupportedCapabilityError('UNSUPPORTED_CAPABILITY', `${this.chain} driver has no block source`);
+                const mapping = {
+                    selection: internals.selection,
+                    driver,
+                    assets: runtime.assets,
+                };
+                return { mapping, blocks, transport };
+            },
+            cursors: runtime.stores.cursors,
+            events: runtime.events,
+            clock: runtime.clock,
+            namespace: runtime.namespace,
+            defaults: {
+                reorgWindow: internals.selection.network.reorgWindow,
+                pollIntervalMs: (0, engine_1.withLifecycleDefaults)(container.effective().lifecycle)
+                    .pollIntervalMs,
+            },
+        }, options);
+    }
+    /** Indexer-backed transaction history of an address (capability `address-history`). */
+    async history(address, options = {}) {
+        if (!this.supports('address-history')) {
+            throw new error_1.UnsupportedCapabilityError('UNSUPPORTED_CAPABILITY', `${this.chain} has no address history (configure an indexer)`);
+        }
+        const { cursor, limit = 50 } = options;
+        if (!Number.isSafeInteger(limit) || limit < 1) {
+            throw new error_1.ConfigError('CONFIG_INVALID', 'history limit must be a positive integer');
+        }
+        if (cursor !== undefined && typeof cursor !== 'string') {
+            throw new error_1.ConfigError('CONFIG_INVALID', 'history cursor must be a string');
+        }
+        const m = await this.mapping();
+        const source = m.driver.history;
+        if (!source)
+            throw new error_1.UnsupportedCapabilityError('UNSUPPORTED_CAPABILITY', `${this.chain} driver has no history source`);
+        const page = await source.list((0, mapping_1.toAddress)(m, address).canonical, {
+            ...(cursor !== undefined ? { cursor } : {}),
+            limit,
+        });
+        const [head, finalized] = await Promise.all([
+            m.driver.reader.getBlockHeight(),
+            m.driver.reader.getFinalizedHeight(),
+        ]);
+        return {
+            items: await Promise.all(page.items.map((tx) => (0, mapping_1.toTransaction)(m, tx, head, finalized))),
+            ...(page.next !== undefined ? { next: page.next } : {}),
+        };
+    }
+    async getNetworkStatus() {
+        const pooled = await (0, internal_1.internalsOf)(this).pooled();
+        await pooled.transport.refreshHealth();
+        if (pooled.indexer)
+            await pooled.indexer.refreshHealth();
+        const [height, finalized] = await Promise.all([
+            pooled.driver.reader.getBlockHeight(),
+            pooled.driver.reader.getFinalizedHeight(),
+        ]);
+        return {
+            chain: this.chain,
+            network: this.network,
+            height,
+            // Two reads, possibly from different endpoints, with blocks landing between
+            // them: where the latest block is final, the finalized height can pass the head read.
+            // Every height below a final one is final, so the clamp keeps the status true.
+            finalizedHeight: finalized > height ? height : finalized,
+            endpoints: pooled.transport.status(),
+            indexers: pooled.indexer?.status() ?? [],
+        };
+    }
+    /** Builds and persists the unsigned transaction (reserving nonce/inputs) for offline or async signing. */
+    async prepareTransfer(intent, options = {}) {
+        const target = await this.target();
+        return this.prepared(target, await this.engine().prepare(target, intent, options));
+    }
+    /**
+     * Idempotent transfer. Throws the mapped chain error when the Operation stalls or fails;
+     * throws an `ambiguous` error (with `context.operationId`) when the broadcast outcome is
+     * unknown. Retry with the same `idempotencyKey` in both cases.
+     */
+    async transfer(intent, options = {}) {
+        const target = await this.target();
+        return this.submission(await this.engine().transfer(target, intent, options));
+    }
+    /**
+     * Completes an Operation that awaits signatures, with signature bundles or with the whole
+     * payload signed elsewhere, e.g. a signed PSBT: the driver extracts its signatures
+     * (`TxBuilder.signaturesFrom`), and each is verified against the stored request exactly
+     * like a bundle. `UNSUPPORTED_CAPABILITY` when the chain's driver cannot read one.
+     */
+    async submitSignatures(operationId, signatures) {
+        const target = await this.target();
+        let bundles;
+        if (Array.isArray(signatures)) {
+            bundles = signatures;
+        }
+        else {
+            if (!isRawTx(signatures)) {
+                throw new error_1.ValidationError('INVALID_INTENT', 'signatures must be signature bundles or a signed payload { encoding, data }');
+            }
+            const { builder } = target.pooled.driver;
+            if (!builder.signaturesFrom) {
+                throw new error_1.UnsupportedCapabilityError('UNSUPPORTED_CAPABILITY', `${this.chain} cannot read a signed payload; submit signature bundles`);
+            }
+            // Ownership first, so another wallet's Operation never reaches the driver.
+            const record = await this.engine().requireOwned(target, operationId);
+            if (!record.unsigned) {
+                throw new error_1.StateError('INVALID_TRANSITION', `operation '${operationId}' has no transaction awaiting signatures`, { context: { operationId } });
+            }
+            try {
+                bundles = builder.signaturesFrom(record.unsigned, signatures);
+            }
+            catch (error) {
+                // A driver's own classified error passes through; a foreign one (an SDK's
+                // parse error, which may quote the payload) becomes a fixed text with no cause.
+                if ((0, error_1.isCryptoAioError)(error))
+                    throw error;
+                throw new error_1.ValidationError('INVALID_INTENT', 'the signed payload could not be read');
+            }
+        }
+        return this.submission(await this.engine().submitSignatures(target, operationId, bundles));
+    }
+    /** Resends the active Attempt's stored raw transaction (e.g. after topping up a stalled wallet). */
+    async rebroadcast(operationId) {
+        return this.submission(await this.engine().rebroadcast(await this.target(), operationId));
+    }
+    /**
+     * Replaces a pending transfer with a higher-fee, mutually exclusive Attempt (capability
+     * `replace-fee`; a synchronous signer). If the node refuses it, the original stays live
+     * and active, and the node's error is thrown.
+     *
+     * Idempotent per fee spec: repeating the call with the same `fee` (the same speed name,
+     * or an equal override) returns the replacement it already made, resending it if its
+     * broadcast was never recorded or it was refused; nothing is signed again, and a refusal
+     * is thrown, never reported as a success. To bump again, pass another spec, such as a
+     * higher explicit override.
+     *
+     * While that replacement is stored but not yet sent, another fee spec (or a cancel) is
+     * refused with `INVALID_TRANSITION`: repeat the same spec, or call `rebroadcast`, first.
+     */
+    async replace(operationId, options) {
+        return this.submission(await this.engine().replace(await this.target(), operationId, options.fee));
+    }
+    /**
+     * Tries to cancel with a conflicting Attempt (capability `cancel`); the outcome is
+     * `cancelled` only if the cancel wins at finality, and the original may still win. The
+     * cancel pays the network's minimum bump over the highest earlier cancel, or `options.fee`
+     * (refused below that bump).
+     *
+     * Repeating the call while a cancel is pending resends it if its broadcast was never
+     * recorded, and returns it while a node holds it or once it is on chain, so concurrent and
+     * retried calls create one cancel. Only a cancel the node refused or dropped is bumped by
+     * a repeat, one step at a time; when the node's minimum fee is more than one bump away,
+     * pass `options.fee`, which always builds a new cancel while none is on chain.
+     *
+     * While a replacement is stored but not yet sent, a cancel is refused with
+     * `INVALID_TRANSITION`: repeat that replacement's fee, or call `rebroadcast`, first.
+     */
+    async cancel(operationId, options = {}) {
+        return this.submission(await this.engine().cancel(await this.target(), operationId, options.fee));
+    }
+    /** Expiry-based chains: re-issues an Operation whose earlier Attempts are provably expired. */
+    async rebuild(operationId) {
+        return this.submission(await this.engine().rebuild(await this.target(), operationId));
+    }
+    /**
+     * Broadcasts an externally signed transaction WITHOUT creating an Operation: no idempotency,
+     * persistence or monitoring. Prefer prepareTransfer + submitSignatures for managed flows.
+     */
+    async broadcast(raw) {
+        const { driver } = await (0, internal_1.internalsOf)(this).pooled();
+        return driver.broadcaster.broadcast({
+            raw,
+            ref: { id: '', idKind: 'tx-hash', canonical: false },
+        });
+    }
+    /** Abandons an Operation that has no signed transaction yet and releases its reservation. */
+    async abandon(operationId) {
+        return this.view(await this.engine().abandon(await this.target(), operationId));
+    }
+    /** An Operation of this handle's chain and network (another one is INVALID_INTENT). */
+    async getOperation(operationId) {
+        const record = await this.engine().get(operationId);
+        if (!record)
+            return null;
+        (0, monitor_1.assertSameNetwork)((0, internal_1.internalsOf)(this).selection, record);
+        return this.view(record);
+    }
+    /** Typed family extensions: `bc.ext.<family>.<method>(...)` (async, loads the adapter on demand). */
+    get ext() {
+        const internals = (0, internal_1.internalsOf)(this);
+        const where = `${internals.selection.chain.id}/${internals.selection.library}`;
+        return new Proxy({}, {
+            get: (_target, family) => {
+                if (typeof family !== 'string' || family === 'then')
+                    return undefined;
+                return new Proxy({}, {
+                    get: (_inner, method) => {
+                        if (typeof method !== 'string' || method === 'then')
+                            return undefined;
+                        return async (...args) => {
+                            const { driver } = await internals.pooled();
+                            // Own-property checks at both levels, so a name inherited from
+                            // Object.prototype (`constructor`, `toString`, ...) can never be mistaken
+                            // for a real family method.
+                            const familyExt = driver.ext && Object.hasOwn(driver.ext, family)
+                                ? driver.ext[family]
+                                : undefined;
+                            const fn = familyExt && Object.hasOwn(familyExt, method)
+                                ? familyExt[method]
+                                : undefined;
+                            if (typeof fn !== 'function') {
+                                throw new error_1.UnsupportedCapabilityError('UNSUPPORTED_CAPABILITY', `ext.${family}.${method} is not available on ${where}`);
+                            }
+                            return fn(...args);
+                        };
+                    },
+                });
+            },
+        });
+    }
+    /** @internal The driver's address for `publicKey` under options the core built. */
+    async driverAddress(publicKey, options) {
+        const { driver, selection } = await this.mapping();
+        return new address_1.Address(selection.chain.id, driver.address.fromPublicKey(publicKey, options), driver.address.format);
+    }
+    /** @internal */
+    async mapping() {
+        const internals = (0, internal_1.internalsOf)(this);
+        const { driver } = await internals.pooled();
+        return {
+            selection: internals.selection,
+            driver,
+            assets: (0, internals_1.containerOf)(internals.container).runtime.assets,
+        };
+    }
+    /** @internal */
+    engine() {
+        const internals = (0, internal_1.internalsOf)(this);
+        internals.assertOpen();
+        return (0, internals_1.containerOf)(internals.container).engine();
+    }
+    /** @internal */
+    monitor() {
+        return (0, internals_1.containerOf)((0, internal_1.internalsOf)(this).container).monitor();
+    }
+    /** @internal */
+    async readTarget() {
+        const internals = (0, internal_1.internalsOf)(this);
+        return { selection: internals.selection, pooled: await internals.pooled() };
+    }
+    /** @internal */
+    async target() {
+        const internals = (0, internal_1.internalsOf)(this);
+        const [pooled, wallet] = await Promise.all([internals.pooled(), internals.wallet()]);
+        return {
+            selection: internals.selection,
+            pooled,
+            wallet,
+            assets: (0, internals_1.containerOf)(internals.container).runtime.assets,
+        };
+    }
+    /** @internal */
+    async view(record) {
+        const { runtime } = (0, internals_1.containerOf)((0, internal_1.internalsOf)(this).container);
+        return (0, views_1.toView)(record, await (0, observations_1.loadObservations)(runtime.stores.operations, record));
+    }
+    /** @internal */
+    async submission(record) {
+        const view = await this.view(record);
+        return {
+            ...view,
+            operationId: view.id,
+            ...(view.activeAttempt ? { attempt: view.activeAttempt } : {}),
+            wait: (options) => this.waitForConfirmation(view.id, options),
+        };
+    }
+    /**
+     * @internal Signing material only while the Operation awaits signatures: an idempotent
+     * repeat of an abandoned Operation returns its view alone.
+     */
+    async prepared(target, record) {
+        const operation = await this.view(record);
+        const unsigned = record.unsigned;
+        if (!unsigned || !engine_1.PRE_SIGNING_STATES.has(record.state))
+            return { operation };
+        const fee = await (0, mapping_1.toFeeEstimate)({
+            selection: target.selection,
+            driver: target.pooled.driver,
+            assets: target.assets,
+        }, unsigned.fee);
+        return {
+            operation,
+            unsigned: {
+                payload: unsigned.payload,
+                signingRequests: unsigned.signingRequests,
+                ...(unsigned.expectedRef ? { expectedRef: unsigned.expectedRef } : {}),
+                fee,
+            },
+        };
+    }
+}
+exports.Blockchain = Blockchain;
+/** The shape of a signed payload (`RawTx`), checked at run time. */
+function isRawTx(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const { encoding, data } = value;
+    return ((encoding === 'hex' || encoding === 'base64' || encoding === 'json') &&
+        typeof data === 'string');
+}
+//# sourceMappingURL=handle.js.map