@bsv/wallet-toolbox 1.7.14 → 1.7.16

package/mobile/node_modules/@bsv/sdk/dist/types/src/transaction/Beef.d.ts

@@ -0,0 +1,248 @@
+import MerklePath from './MerklePath.js';
+import Transaction from './Transaction.js';
+import ChainTracker from './ChainTracker.js';
+import BeefTx from './BeefTx.js';
+import { Reader, Writer } from '../primitives/utils.js';
+export declare const BEEF_V1 = 4022206465;
+export declare const BEEF_V2 = 4022206466;
+export declare const ATOMIC_BEEF = 16843009;
+export declare enum TX_DATA_FORMAT {
+    RAWTX = 0,// rawtx without BUMP
+    RAWTX_AND_BUMP_INDEX = 1,// rawtx with bump index
+    TXID_ONLY = 2
+}
+export declare class Beef {
+    bumps: MerklePath[];
+    txs: BeefTx[];
+    version: number;
+    atomicTxid: string | undefined;
+    private txidIndex;
+    private rawBytesCache?;
+    private hexCache?;
+    private needsSort;
+    constructor(version?: number);
+    private invalidateSerializationCaches;
+    private markMutated;
+    private ensureSerializableState;
+    private ensureSortedForSerialization;
+    private getSerializedBytes;
+    /**
+     * @param txid of `beefTx` to find
+     * @returns `BeefTx` in `txs` with `txid`.
+     */
+    findTxid(txid: string): BeefTx | undefined;
+    private ensureTxidIndex;
+    private deleteFromIndex;
+    private addToIndex;
+    /**
+     * Replaces `BeefTx` for this txid with txidOnly.
+     *
+     * Replacement is done so that a `clone()` can be
+     * updated by this method without affecting the
+     * original.
+     *
+     * @param txid
+     * @returns undefined if txid is unknown.
+     */
+    makeTxidOnly(txid: string): BeefTx | undefined;
+    /**
+     * @returns `MerklePath` with level zero hash equal to txid or undefined.
+     */
+    findBump(txid: string): MerklePath | undefined;
+    /**
+     * Finds a Transaction in this `Beef`
+     * and adds any missing input SourceTransactions from this `Beef`.
+     *
+     * The result is suitable for signing.
+     *
+     * @param txid The id of the target transaction.
+     * @returns Transaction with all available input `SourceTransaction`s from this Beef.
+     */
+    findTransactionForSigning(txid: string): Transaction | undefined;
+    /**
+     * Builds the proof tree rooted at a specific `Transaction`.
+     *
+     * To succeed, the Beef must contain all the required transaction and merkle path data.
+     *
+     * @param txid The id of the target transaction.
+     * @returns Transaction with input `SourceTransaction` and `MerklePath` populated from this Beef.
+     */
+    findAtomicTransaction(txid: string): Transaction | undefined;
+    /**
+     * Merge a MerklePath that is assumed to be fully valid.
+     * @param bump
+     * @returns index of merged bump
+     */
+    mergeBump(bump: MerklePath): number;
+    /**
+     * Merge a serialized transaction.
+     *
+     * Checks that a transaction with the same txid hasn't already been merged.
+     *
+     * Replaces existing transaction with same txid.
+     *
+     * @param rawTx
+     * @param bumpIndex Optional. If a number, must be valid index into bumps array.
+     * @returns txid of rawTx
+     */
+    mergeRawTx(rawTx: number[], bumpIndex?: number): BeefTx;
+    /**
+     * Merge a `Transaction` and any referenced `merklePath` and `sourceTransaction`, recursifely.
+     *
+     * Replaces existing transaction with same txid.
+     *
+     * Attempts to match an existing bump to the new transaction.
+     *
+     * @param tx
+     * @returns txid of tx
+     */
+    mergeTransaction(tx: Transaction): BeefTx;
+    /**
+     * Removes an existing transaction from the BEEF, given its TXID
+     * @param txid TXID of the transaction to remove
+     */
+    removeExistingTxid(txid: string): void;
+    mergeTxidOnly(txid: string): BeefTx;
+    mergeBeefTx(btx: BeefTx): BeefTx;
+    mergeBeef(beef: number[] | Beef): void;
+    /**
+     * Sorts `txs` and checks structural validity of beef.
+     *
+     * Does NOT verify merkle roots.
+     *
+     * Validity requirements:
+     * 1. No 'known' txids, unless `allowTxidOnly` is true.
+     * 2. All transactions have bumps or their inputs chain back to bumps (or are known).
+     * 3. Order of transactions satisfies dependencies before dependents.
+     * 4. No transactions with duplicate txids.
+     *
+     * @param allowTxidOnly optional. If true, transaction txid only is assumed valid
+     */
+    isValid(allowTxidOnly?: boolean): boolean;
+    /**
+     * Sorts `txs` and confirms validity of transaction data contained in beef
+     * by validating structure of this beef and confirming computed merkle roots
+     * using `chainTracker`.
+     *
+     * Validity requirements:
+     * 1. No 'known' txids, unless `allowTxidOnly` is true.
+     * 2. All transactions have bumps or their inputs chain back to bumps (or are known).
+     * 3. Order of transactions satisfies dependencies before dependents.
+     * 4. No transactions with duplicate txids.
+     *
+     * @param chainTracker Used to verify computed merkle path roots for all bump txids.
+     * @param allowTxidOnly optional. If true, transaction txid is assumed valid
+     */
+    verify(chainTracker: ChainTracker, allowTxidOnly?: boolean): Promise<boolean>;
+    /**
+     * Sorts `txs` and confirms validity of transaction data contained in beef
+     * by validating structure of this beef.
+     *
+     * Returns block heights and merkle root values to be confirmed by a chaintracker.
+     *
+     * Validity requirements:
+     * 1. No 'known' txids, unless `allowTxidOnly` is true.
+     * 2. All transactions have bumps or their inputs chain back to bumps (or are known).
+     * 3. Order of transactions satisfies dependencies before dependents.
+     * 4. No transactions with duplicate txids.
+     *
+     * @param allowTxidOnly optional. If true, transaction txid is assumed valid
+     * @returns {{valid: boolean, roots: Record<number, string>}}
+     * `valid` is true iff this Beef is structuraly valid.
+     * `roots` is a record where keys are block heights and values are the corresponding merkle roots to be validated.
+     */
+    verifyValid(allowTxidOnly?: boolean): {
+        valid: boolean;
+        roots: Record<number, string>;
+    };
+    /**
+     * Serializes this data to `writer`
+     * @param writer
+     */
+    toWriter(writer: Writer): void;
+    /**
+     * Returns a binary array representing the serialized BEEF
+     * @returns A binary array representing the BEEF
+     */
+    toBinary(): number[];
+    toUint8Array(): Uint8Array;
+    /**
+     * Serialize this Beef as AtomicBEEF.
+     *
+     * `txid` must exist
+     *
+     * after sorting, if txid is not last txid, creates a clone and removes newer txs
+     *
+     * @param txid
+     * @returns serialized contents of this Beef with AtomicBEEF prefix.
+     */
+    toBinaryAtomic(txid: string): number[];
+    /**
+     * Returns a hex string representing the serialized BEEF
+     * @returns A hex string representing the BEEF
+     */
+    toHex(): string;
+    static fromReader(br: Reader): Beef;
+    /**
+     * Constructs an instance of the Beef class based on the provided binary array
+     * @param bin The binary array from which to construct BEEF
+     * @returns An instance of the Beef class constructed from the binary data
+     */
+    static fromBinary(bin: number[]): Beef;
+    /**
+     * Constructs an instance of the Beef class based on the provided string
+     * @param s The string value from which to construct BEEF
+     * @param enc The encoding of the string value from which BEEF should be constructed
+     * @returns An instance of the Beef class constructed from the string
+     */
+    static fromString(s: string, enc?: 'hex' | 'utf8' | 'base64'): Beef;
+    /**
+     * Try to validate newTx.bumpIndex by looking for an existing bump
+     * that proves newTx.txid
+     *
+     * @param newTx A new `BeefTx` that has been added to this.txs
+     * @returns true if a bump was found, false otherwise
+     */
+    private tryToValidateBumpIndex;
+    /**
+     * Sort the `txs` by input txid dependency order:
+     * - Oldest Tx Anchored by Path or txid only
+     * - Newer Txs depending on Older parents
+     * - Newest Tx
+     *
+     * with proof (MerklePath) last, longest chain of dependencies first
+     *
+     * @returns `{ missingInputs, notValid, valid, withMissingInputs }`
+     */
+    sortTxs(): {
+        missingInputs: string[];
+        notValid: string[];
+        valid: string[];
+        withMissingInputs: string[];
+        txidOnly: string[];
+    };
+    /**
+     * @returns a shallow copy of this beef
+     */
+    clone(): Beef;
+    /**
+     * Ensure that all the txids in `knownTxids` are txidOnly
+     * @param knownTxids
+     */
+    trimKnownTxids(knownTxids: string[]): void;
+    /**
+     * @returns array of transaction txids that either have a proof or whose inputs chain back to a proven transaction.
+     */
+    getValidTxids(): string[];
+    /**
+     * @returns Summary of `Beef` contents as multi-line string.
+     */
+    toLogString(): string;
+    /**
+   * In some circumstances it may be helpful for the BUMP MerklePaths to include
+   * leaves that can be computed from row zero.
+   */
+    addComputedLeaves(): void;
+}
+export default Beef;
+//# sourceMappingURL=Beef.d.ts.map

package/mobile/node_modules/@bsv/sdk/dist/types/src/transaction/Beef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Beef.d.ts","sourceRoot":"","sources":["../../../../src/transaction/Beef.ts"],"names":[],"mappings":"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"}

package/mobile/node_modules/@bsv/sdk/dist/types/src/transaction/BeefParty.d.ts

@@ -0,0 +1,73 @@
+import { Beef } from './Beef.js';
+/**
+ * Extends `Beef` that is used to exchange transaction validity data with more than one external party.
+ *
+ * Use `addKnownTxidsForParty` to keep track of who knows what to reduce re-transmission of potentially large transactions.
+ *
+ * Use `getTrimmedBeefForParty` to obtain a `Beef` trimmed of transaction validity data known to a specific party.
+ *
+ * Typical usage scenario:
+ *
+ * 1. Query a wallet storage provider for spendable outputs.
+ * 2. The provider replies with a Beef validating the returned outputs.
+ * 3. Construct a new transaction using some of the queried outputs as inputs, including Beef validating all the inputs.
+ * 4. Receive new valid raw transaction after processing and Beef validating change outputs added to original inputs.
+ * 5. Return to step 1, continuing to build on old and new spendable outputs.
+ *
+ * By default, each Beef is required to be complete and valid: All transactions appear as full serialized bitcoin transactions and
+ * each transaction either has a merkle path proof (it has been mined) or all of its input transactions are included.
+ *
+ * The size and redundancy of these Beefs becomes a problem when chained transaction creation out-paces the block mining rate.
+ *
+ */
+export declare class BeefParty extends Beef {
+    /**
+     * keys are party identifiers.
+     * values are records of txids with truthy value for which the party already has validity proof.
+     */
+    knownTo: Record<string, Record<string, boolean>>;
+    /**
+     *
+     * @param parties Optional array of initial unique party identifiers.
+     */
+    constructor(parties?: string[]);
+    /**
+     * @param party
+     * @returns `true` if `party` has already been added to this `BeefParty`.
+     */
+    isParty(party: string): boolean;
+    /**
+     * Adds a new unique party identifier to this `BeefParty`.
+     * @param party
+     */
+    addParty(party: string): void;
+    /**
+     * @param party
+     * @returns Array of txids "known" to `party`.
+     */
+    getKnownTxidsForParty(party: string): string[];
+    /**
+     * @param party
+     * @returns trimmed beef of unknown transactions and proofs for `party`
+     */
+    getTrimmedBeefForParty(party: string): Beef;
+    /**
+     * Make note of additional txids "known" to `party`.
+     * @param party unique identifier, added if new.
+     * @param knownTxids
+     */
+    addKnownTxidsForParty(party: string, knownTxids: string[]): void;
+    /**
+     * Merge a `beef` received from a specific `party`.
+     *
+     * Updates this `BeefParty` to track all the txids
+     * corresponding to transactions for which `party`
+     * has raw transaction and validity proof data.
+     *
+     * @param party
+     * @param beef
+     */
+    mergeBeefFromParty(party: string, beef: number[] | Beef): void;
+}
+export default BeefParty;
+//# sourceMappingURL=BeefParty.d.ts.map

package/mobile/node_modules/@bsv/sdk/dist/types/src/transaction/BeefParty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BeefParty.d.ts","sourceRoot":"","sources":["../../../../src/transaction/BeefParty.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAEhC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,SAAU,SAAQ,IAAI;IACjC;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAK;IAErD;;;OAGG;gBACU,OAAO,CAAC,EAAE,MAAM,EAAE;IAS/B;;;OAGG;IACH,OAAO,CAAE,KAAK,EAAE,MAAM,GAAG,OAAO;IAKhC;;;OAGG;IACH,QAAQ,CAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAO9B;;;OAGG;IACH,qBAAqB,CAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE;IAU/C;;;OAGG;IACH,sBAAsB,CAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAO5C;;;;OAIG;IACH,qBAAqB,CAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,IAAI;IAWjE;;;;;;;;;OASG;IACH,kBAAkB,CAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,GAAG,IAAI;CAMhE;AAED,eAAe,SAAS,CAAA"}

package/mobile/node_modules/@bsv/sdk/dist/types/src/transaction/BeefTx.d.ts

@@ -0,0 +1,43 @@
+import { Reader, Writer } from '../primitives/utils.js';
+import Transaction from './Transaction.js';
+/**
+ * A single bitcoin transaction associated with a `Beef` validity proof set.
+ *
+ * Simple case is transaction data included directly, either as raw bytes or fully parsed data, or both.
+ *
+ * Supports 'known' transactions which are represented by just their txid.
+ * It is assumed that intended consumer of this beef already has validity proof for such a transaction,
+ * which they can merge if necessary to create a valid beef.
+ */
+export default class BeefTx {
+    _bumpIndex?: number;
+    _tx?: Transaction;
+    _rawTx?: number[];
+    _txid?: string;
+    inputTxids: string[];
+    /**
+     * true if `hasProof` or all inputs chain to `hasProof`.
+     *
+     * Typically set by sorting transactions by proven dependency chains.
+     */
+    isValid?: boolean;
+    get bumpIndex(): number | undefined;
+    set bumpIndex(v: number | undefined);
+    get hasProof(): boolean;
+    get isTxidOnly(): boolean;
+    get txid(): string;
+    get tx(): Transaction | undefined;
+    get rawTx(): number[] | undefined;
+    /**
+     * @param tx If string, must be a valid txid. If `number[]` must be a valid serialized transaction.
+     * @param bumpIndex If transaction already has a proof in the beef to which it will be added.
+     */
+    constructor(tx: Transaction | number[] | string, bumpIndex?: number);
+    static fromTx(tx: Transaction, bumpIndex?: number): BeefTx;
+    static fromRawTx(rawTx: number[], bumpIndex?: number): BeefTx;
+    static fromTxid(txid: string, bumpIndex?: number): BeefTx;
+    private updateInputTxids;
+    toWriter(writer: Writer, version: number): void;
+    static fromReader(br: Reader, version: number): BeefTx;
+}
+//# sourceMappingURL=BeefTx.d.ts.map

package/mobile/node_modules/@bsv/sdk/dist/types/src/transaction/BeefTx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BeefTx.d.ts","sourceRoot":"","sources":["../../../../src/transaction/BeefTx.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAkB,MAAM,wBAAwB,CAAA;AACvE,OAAO,WAAW,MAAM,kBAAkB,CAAA;AAG1C;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,OAAO,MAAM;IACzB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,GAAG,CAAC,EAAE,WAAW,CAAA;IACjB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,EAAE,CAAK;IACzB;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAY;IAE7B,IAAI,SAAS,IAAK,MAAM,GAAG,SAAS,CAEnC;IAED,IAAI,SAAS,CAAE,CAAC,EAAE,MAAM,GAAG,SAAS,EAGnC;IAED,IAAI,QAAQ,IAAK,OAAO,CAEvB;IAED,IAAI,UAAU,IAAK,OAAO,CAEzB;IAED,IAAI,IAAI,IAAK,MAAM,CAWlB;IAED,IAAI,EAAE,IAAK,WAAW,GAAG,SAAS,CAOjC;IAED,IAAI,KAAK,IAAK,MAAM,EAAE,GAAG,SAAS,CAOjC;IAED;;;OAGG;gBACU,EAAE,EAAE,WAAW,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM;IAYpE,MAAM,CAAC,MAAM,CAAE,EAAE,EAAE,WAAW,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM;IAI3D,MAAM,CAAC,SAAS,CAAE,KAAK,EAAE,MAAM,EAAE,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM;IAI9D,MAAM,CAAC,QAAQ,CAAE,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM;IAI1D,OAAO,CAAC,gBAAgB;IAgBxB,QAAQ,CAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAiDhD,MAAM,CAAC,UAAU,CAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM;CAyBxD"}

package/mobile/node_modules/@bsv/sdk/dist/types/src/transaction/Broadcaster.d.ts

@@ -0,0 +1,55 @@
+import Transaction from './Transaction.js';
+/**
+ * Defines the structure of a successful broadcast response.
+ *
+ * @interface
+ * @property {string} status - The status of the response, indicating success.
+ * @property {string} txid - The transaction ID of the broadcasted transaction.
+ * @property {string} message - A human-readable success message.
+ */
+export interface BroadcastResponse {
+    status: 'success';
+    txid: string;
+    message: string;
+    competingTxs?: string[];
+}
+/**
+ * Defines the structure of a failed broadcast response.
+ *
+ * @interface
+ * @property {string} status - The status of the response, indicating an error.
+ * @property {string} code - A machine-readable error code representing the type of error encountered.
+ * @property {string} txid - The transaction ID of the broadcasted transaction.
+ * @property {string} description - A detailed description of the error.
+ * @property {object} more - The unparsed response data from the underlying broadcast service.
+ */
+export interface BroadcastFailure {
+    status: 'error';
+    code: string;
+    txid?: string;
+    description: string;
+    more?: object;
+}
+/**
+ * Represents the interface for a transaction broadcaster.
+ * This interface defines a standard method for broadcasting transactions.
+ *
+ * @interface
+ * @property {function} broadcast - A function that takes a Transaction object and returns a promise.
+ *                                  The promise resolves to either a BroadcastResponse or a BroadcastFailure.
+ * @property {function} broadcastMany - A function that takes an array of Transaction objects and returns a promise.
+ *                                  The promise resolves to an array of broadcast result response objects.
+ */
+export interface Broadcaster {
+    broadcast: (transaction: Transaction) => Promise<BroadcastResponse | BroadcastFailure>;
+    broadcastMany?: (txs: Transaction[]) => Promise<object[]>;
+}
+/**
+ * Convenience type guard for response from `Broadcaster.broadcast`
+ */
+export declare function isBroadcastResponse(r: BroadcastResponse | BroadcastFailure): r is BroadcastResponse;
+/**
+ * Convenience type guard for response from `Broadcaster.broadcast`
+ */
+export declare function isBroadcastFailure(r: BroadcastResponse | BroadcastFailure): r is BroadcastFailure;
+//# sourceMappingURL=Broadcaster.d.ts.map

package/mobile/node_modules/@bsv/sdk/dist/types/src/transaction/Broadcaster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Broadcaster.d.ts","sourceRoot":"","sources":["../../../../src/transaction/Broadcaster.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,kBAAkB,CAAA;AAE1C;;;;;;;GAOG;AACH,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,SAAS,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;CACxB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,OAAO,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,CACT,WAAW,EAAE,WAAW,KACrB,OAAO,CAAC,iBAAiB,GAAG,gBAAgB,CAAC,CAAA;IAClD,aAAa,CAAC,EAAE,CAAC,GAAG,EAAE,WAAW,EAAE,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;CAC1D;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,CAAC,EAAE,iBAAiB,GAAG,gBAAgB,GACtC,CAAC,IAAI,iBAAiB,CAExB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,CAAC,EAAE,iBAAiB,GAAG,gBAAgB,GACtC,CAAC,IAAI,gBAAgB,CAEvB"}

package/mobile/node_modules/@bsv/sdk/dist/types/src/transaction/ChainTracker.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The Chain Tracker is responsible for verifying the validity of a given Merkle root
+ * for a specific block height within the blockchain.
+ *
+ * Chain Trackers ensure the integrity of the blockchain by
+ * validating new headers against the chain's history. They use accumulated
+ * proof-of-work and protocol adherence as metrics to assess the legitimacy of blocks.
+ *
+ * @interface ChainTracker
+ * @function isValidRootForHeight - A method to verify the validity of a Merkle root
+ *          for a given block height.
+ *
+ * @function currentHeight - A method to get the current block height.
+ *
+ * @example
+ * const chainTracker = {
+ *   isValidRootForHeight: async (root, height) => {
+ *     // Implementation to check if the Merkle root is valid for the specified block height.
+ *   }
+ *  currentHeight: async () => {
+ *     // Implementation to get the current block height.
+ *   }
+ * };
+ */
+export default interface ChainTracker {
+    isValidRootForHeight: (root: string, height: number) => Promise<boolean>;
+    currentHeight: () => Promise<number>;
+}
+//# sourceMappingURL=ChainTracker.d.ts.map

package/mobile/node_modules/@bsv/sdk/dist/types/src/transaction/ChainTracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChainTracker.d.ts","sourceRoot":"","sources":["../../../../src/transaction/ChainTracker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,OAAO,WAAW,YAAY;IACnC,oBAAoB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IACxE,aAAa,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAA;CACrC"}

package/mobile/node_modules/@bsv/sdk/dist/types/src/transaction/FeeModel.d.ts

@@ -0,0 +1,12 @@
+import Transaction from './Transaction.js';
+/**
+ * Represents the interface for a transaction fee model.
+ * This interface defines a standard method for computing a fee when given a transaction.
+ *
+ * @interface
+ * @property {function} computeFee - A function that takes a Transaction object and returns a BigNumber representing the number of satoshis the transaction should cost.
+ */
+export default interface FeeModel {
+    computeFee: (transaction: Transaction) => Promise<number>;
+}
+//# sourceMappingURL=FeeModel.d.ts.map

package/mobile/node_modules/@bsv/sdk/dist/types/src/transaction/FeeModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FeeModel.d.ts","sourceRoot":"","sources":["../../../../src/transaction/FeeModel.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,kBAAkB,CAAA;AAE1C;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,WAAW,QAAQ;IAC/B,UAAU,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;CAC1D"}

package/mobile/node_modules/@bsv/sdk/dist/types/src/transaction/MerklePath.d.ts

@@ -0,0 +1,125 @@
+import { Reader } from '../primitives/utils.js';
+import ChainTracker from './ChainTracker.js';
+export interface MerklePathLeaf {
+    offset: number;
+    hash?: string;
+    txid?: boolean;
+    duplicate?: boolean;
+}
+/**
+ * Represents a Merkle Path, which is used to provide a compact proof of inclusion for a
+ * transaction in a block. This class encapsulates all the details required for creating
+ * and verifying Merkle Proofs.
+ *
+ * @class MerklePath
+ * @property {number} blockHeight - The height of the block in which the transaction is included.
+ * @property {Array<Array<{offset: number, hash?: string, txid?: boolean, duplicate?: boolean}>>} path -
+ *           A tree structure representing the Merkle Path, with each level containing information
+ *           about the nodes involved in constructing the proof.
+ *
+ * @example
+ * // Creating and verifying a Merkle Path
+ * const merklePath = MerklePath.fromHex('...');
+ * const isValid = merklePath.verify(txid, chainTracker);
+ *
+ * @description
+ * The MerklePath class is useful for verifying transactions in a lightweight and efficient manner without
+ * needing the entire block data. This class offers functionalities for creating, converting,
+ * and verifying these proofs.
+ */
+export default class MerklePath {
+    blockHeight: number;
+    path: Array<Array<{
+        offset: number;
+        hash?: string;
+        txid?: boolean;
+        duplicate?: boolean;
+    }>>;
+    /**
+     * Creates a MerklePath instance from a hexadecimal string.
+     *
+     * @static
+     * @param {string} hex - The hexadecimal string representation of the Merkle Path.
+     * @returns {MerklePath} - A new MerklePath instance.
+     */
+    static fromHex(hex: string): MerklePath;
+    static fromReader(reader: Reader, legalOffsetsOnly?: boolean): MerklePath;
+    /**
+     * Creates a MerklePath instance from a binary array.
+     *
+     * @static
+     * @param {number[]} bump - The binary array representation of the Merkle Path.
+     * @returns {MerklePath} - A new MerklePath instance.
+     */
+    static fromBinary(bump: number[]): MerklePath;
+    /**
+     *
+     * @static fromCoinbaseTxid
+     *
+     * Creates a MerklePath instance for a coinbase transaction in an empty block.
+     * This edge case is difficult to retrieve from standard APIs.
+     *
+     * @param {string} txid - The coinbase txid.
+     * @param {number} height - The height of the block.
+     * @returns {MerklePath} - A new MerklePath instance which assumes the tx is in a block with no other transactions.
+     */
+    static fromCoinbaseTxidAndHeight(txid: string, height: number): MerklePath;
+    constructor(blockHeight: number, path: Array<Array<{
+        offset: number;
+        hash?: string;
+        txid?: boolean;
+        duplicate?: boolean;
+    }>>, legalOffsetsOnly?: boolean);
+    /**
+     * Converts the MerklePath to a binary array format.
+     *
+     * @returns {number[]} - The binary array representation of the Merkle Path.
+     */
+    toBinary(): number[];
+    /**
+     * Converts the MerklePath to a hexadecimal string format.
+     *
+     * @returns {string} - The hexadecimal string representation of the Merkle Path.
+     */
+    toHex(): string;
+    private indexOf;
+    /**
+     * Computes the Merkle root from the provided transaction ID.
+     *
+     * @param {string} txid - The transaction ID to compute the Merkle root for. If not provided, the root will be computed from an unspecified branch, and not all branches will be validated!
+     * @returns {string} - The computed Merkle root as a hexadecimal string.
+     * @throws {Error} - If the transaction ID is not part of the Merkle Path.
+     */
+    computeRoot(txid?: string): string;
+    /**
+     * Find leaf with `offset` at `height` or compute from level below, recursively.
+     *
+     * Does not add computed leaves to path.
+     *
+     * @param height
+     * @param offset
+     */
+    findOrComputeLeaf(height: number, offset: number): MerklePathLeaf | undefined;
+    /**
+     * Verifies if the given transaction ID is part of the Merkle tree at the specified block height.
+     *
+     * @param {string} txid - The transaction ID to verify.
+     * @param {ChainTracker} chainTracker - The ChainTracker instance used to verify the Merkle root.
+     * @returns {boolean} - True if the transaction ID is valid within the Merkle Path at the specified block height.
+     */
+    verify(txid: string, chainTracker: ChainTracker): Promise<boolean>;
+    /**
+     * Combines this MerklePath with another to create a compound proof.
+     *
+     * @param {MerklePath} other - Another MerklePath to combine with this path.
+     * @throws {Error} - If the paths have different block heights or roots.
+     */
+    combine(other: MerklePath): void;
+    /**
+     * Remove all internal nodes that are not required by level zero txid nodes.
+     * Assumes that at least all required nodes are present.
+     * Leaves all levels sorted by increasing offset.
+     */
+    trim(): void;
+}
+//# sourceMappingURL=MerklePath.d.ts.map

package/mobile/node_modules/@bsv/sdk/dist/types/src/transaction/MerklePath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MerklePath.d.ts","sourceRoot":"","sources":["../../../../src/transaction/MerklePath.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAA0B,MAAM,wBAAwB,CAAA;AAEvE,OAAO,YAAY,MAAM,mBAAmB,CAAA;AAE5C,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,OAAO,OAAO,UAAU;IAC7B,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,KAAK,CACX,KAAK,CAAC;QACJ,MAAM,EAAE,MAAM,CAAA;QACd,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,IAAI,CAAC,EAAE,OAAO,CAAA;QACd,SAAS,CAAC,EAAE,OAAO,CAAA;KACpB,CAAC,CACD,CAAA;IAED;;;;;;OAMG;IACH,MAAM,CAAC,OAAO,CAAE,GAAG,EAAE,MAAM,GAAG,UAAU;IAIxC,MAAM,CAAC,UAAU,CACf,MAAM,EAAE,MAAM,EACd,gBAAgB,GAAE,OAAc,GAC/B,UAAU;IAwCb;;;;;;OAMG;IACH,MAAM,CAAC,UAAU,CAAE,IAAI,EAAE,MAAM,EAAE,GAAG,UAAU;IAK9C;;;;;;;;;;OAUG;IACH,MAAM,CAAC,yBAAyB,CAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,UAAU;gBAKzE,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,KAAK,CACX,KAAK,CAAC;QACJ,MAAM,EAAE,MAAM,CAAA;QACd,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,IAAI,CAAC,EAAE,OAAO,CAAA;QACd,SAAS,CAAC,EAAE,OAAO,CAAA;KACpB,CAAC,CACD,EACD,gBAAgB,GAAE,OAAc;IA+ClC;;;;OAIG;IACH,QAAQ,IAAK,MAAM,EAAE;IA0BrB;;;;OAIG;IACH,KAAK,IAAK,MAAM;IAKhB,OAAO,CAAC,OAAO;IAQf;;;;;;OAMG;IACH,WAAW,CAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM;IA2CnC;;;;;;;OAOG;IACH,iBAAiB,CACf,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,cAAc,GAAG,SAAS;IAmC7B;;;;;;OAMG;IACG,MAAM,CAAE,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC;IAazE;;;;;OAKG;IACH,OAAO,CAAE,KAAK,EAAE,UAAU,GAAG,IAAI;IA2CjC;;;;OAIG;IACH,IAAI,IAAK,IAAI;CAqDd"}