@bsv/sdk 1.2.1 → 1.2.3

package/docs/transaction.md

@@ -19,100 +19,77 @@ Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](
 
 ---
 
-### Interface: TransactionInput
-
-Represents an input to a Bitcoin transaction.
-This interface defines the structure and components required to construct
-a transaction input in the Bitcoin blockchain.
-
-Example
-
-```ts
-// Creating a simple transaction input
-let txInput = {
-  sourceTXID: '123abc...',
-  sourceOutputIndex: 0,
-  sequence: 0xFFFFFFFF
-};
+### Interface: ArcConfig
 
-// Using an unlocking script template
-txInput.unlockingScriptTemplate = {
-  sign: async (tx, index) => { ... },
-  estimateLength: async (tx, index) => { ... }
-};
-```
+Configuration options for the ARC broadcaster.
 
 ```ts
-export default interface TransactionInput {
-    sourceTransaction?: Transaction;
-    sourceTXID?: string;
-    sourceOutputIndex: number;
-    unlockingScript?: UnlockingScript;
-    unlockingScriptTemplate?: {
-        sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>;
-        estimateLength: (tx: Transaction, inputIndex: number) => Promise<number>;
-    };
-    sequence?: number;
+export interface ArcConfig {
+    apiKey?: string;
+    httpClient?: HttpClient;
+    deploymentId?: string;
+    callbackUrl?: string;
+    callbackToken?: string;
+    headers?: Record<string, string>;
 }
 ```
 
-Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
+See also: [HttpClient](#interface-httpclient)
 
----
-### Interface: TransactionOutput
+<details>
 
-Represents an output in a Bitcoin transaction.
-This interface defines the structure and components necessary to construct
-a transaction output, which secures owned Bitcoins to be unlocked later.
+<summary>Interface ArcConfig Details</summary>
 
-Example
+#### Property apiKey
+
+Authentication token for the ARC API
 
 ```ts
-// Creating a simple transaction output
-let txOutput = {
-  satoshis: 1000,
-  lockingScript: LockingScript.fromASM('OP_DUP OP_HASH160 ... OP_EQUALVERIFY OP_CHECKSIG'),
-  change: false
-};
+apiKey?: string
 ```
 
+#### Property callbackToken
+
+default access token for notification callback endpoint. It will be used as a Authorization header for the http callback
+
 ```ts
-export default interface TransactionOutput {
-    satoshis?: number;
-    lockingScript: LockingScript;
-    change?: boolean;
-}
+callbackToken?: string
 ```
 
-Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
+#### Property callbackUrl
 
----
-### Interface: FeeModel
+notification callback endpoint for proofs and double spend notification
 
-Represents the interface for a transaction fee model.
-This interface defines a standard method for computing a fee when given a transaction.
+```ts
+callbackUrl?: string
+```
+
+#### Property deploymentId
+
+Deployment id used annotating api calls in XDeployment-ID header - this value will be randomly generated if not set
 
 ```ts
-export default interface FeeModel {
-    computeFee: (transaction: Transaction) => Promise<number>;
-}
+deploymentId?: string
 ```
 
-Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
+#### Property headers
 
----
-### Interface: BroadcastResponse
+additional headers to be attached to all tx submissions.
 
-Defines the structure of a successful broadcast response.
+```ts
+headers?: Record<string, string>
+```
+
+#### Property httpClient
+
+The HTTP client used to make requests to the ARC API.
 
 ```ts
-export interface BroadcastResponse {
-    status: "success";
-    txid: string;
-    message: string;
-    competingTxs?: string[];
-}
+httpClient?: HttpClient
 ```
+See also: [HttpClient](#interface-httpclient)
+
+</details>
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
@@ -133,6 +110,22 @@ export interface BroadcastFailure {
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
+---
+### Interface: BroadcastResponse
+
+Defines the structure of a successful broadcast response.
+
+```ts
+export interface BroadcastResponse {
+    status: "success";
+    txid: string;
+    message: string;
+    competingTxs?: string[];
+}
+```
+
+Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
+
 ---
 ### Interface: Broadcaster
 
@@ -145,6 +138,8 @@ export interface Broadcaster {
 }
 ```
 
+See also: [BroadcastFailure](#interface-broadcastfailure), [BroadcastResponse](#interface-broadcastresponse), [Transaction](#class-transaction)
+
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
 ---
@@ -176,17 +171,65 @@ export default interface ChainTracker {
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
 ---
-### Interface: MerklePathLeaf
+### Interface: FeeModel
+
+Represents the interface for a transaction fee model.
+This interface defines a standard method for computing a fee when given a transaction.
 
 ```ts
-export interface MerklePathLeaf {
-    offset: number;
-    hash?: string;
-    txid?: boolean;
-    duplicate?: boolean;
+export default interface FeeModel {
+    computeFee: (transaction: Transaction) => Promise<number>;
+}
+```
+
+See also: [Transaction](#class-transaction)
+
+Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
+
+---
+### Interface: FetchOptions
+
+An interface for configuration of the request to be passed to the fetch method
+limited to options needed by ts-sdk.
+
+```ts
+export interface FetchOptions {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string | null;
 }
 ```
 
+<details>
+
+<summary>Interface FetchOptions Details</summary>
+
+#### Property body
+
+An object or null to set request's body.
+
+```ts
+body?: string | null
+```
+
+#### Property headers
+
+An object literal set request's headers.
+
+```ts
+headers?: Record<string, string>
+```
+
+#### Property method
+
+A string to set request's method.
+
+```ts
+method?: string
+```
+
+</details>
+
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
 ---
@@ -200,6 +243,8 @@ export interface HttpClient {
 }
 ```
 
+See also: [HttpClientRequestOptions](#interface-httpclientrequestoptions), [HttpClientResponse](#type-httpclientresponse)
+
 <details>
 
 <summary>Interface HttpClient Details</summary>
@@ -211,6 +256,7 @@ Makes a request to the server.
 ```ts
 request: <T = any, D = any>(url: string, options: HttpClientRequestOptions<D>) => Promise<HttpClientResponse<T>>
 ```
+See also: [HttpClientRequestOptions](#interface-httpclientrequestoptions), [HttpClientResponse](#type-httpclientresponse)
 
 </details>
 
@@ -272,138 +318,108 @@ export interface HttpsNodejs {
 }
 ```
 
+See also: [HttpClientRequestOptions](#interface-httpclientrequestoptions), [NodejsHttpClientRequest](#interface-nodejshttpclientrequest)
+
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
 ---
-### Interface: NodejsHttpClientRequest
-
-Nodejs result of the Node.js https.request call limited to options needed by ts-sdk
+### Interface: MerklePathLeaf
 
 ```ts
-export interface NodejsHttpClientRequest {
-    write: (chunk: string) => void;
-    on: (event: string, callback: (data: any) => void) => void;
-    end: (() => void) & (() => void);
+export interface MerklePathLeaf {
+    offset: number;
+    hash?: string;
+    txid?: boolean;
+    duplicate?: boolean;
 }
 ```
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
 ---
-### Interface: FetchOptions
+### Interface: NodejsHttpClientRequest
 
-An interface for configuration of the request to be passed to the fetch method
-limited to options needed by ts-sdk.
+Nodejs result of the Node.js https.request call limited to options needed by ts-sdk
 
 ```ts
-export interface FetchOptions {
-    method?: string;
-    headers?: Record<string, string>;
-    body?: string | null;
+export interface NodejsHttpClientRequest {
+    write: (chunk: string) => void;
+    on: (event: string, callback: (data: any) => void) => void;
+    end: (() => void) & (() => void);
 }
 ```
 
-<details>
+Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
-<summary>Interface FetchOptions Details</summary>
+---
+### Interface: TransactionInput
 
-#### Property body
+Represents an input to a Bitcoin transaction.
+This interface defines the structure and components required to construct
+a transaction input in the Bitcoin blockchain.
 
-An object or null to set request's body.
+Example
 
 ```ts
-body?: string | null
-```
-
-#### Property headers
+// Creating a simple transaction input
+let txInput = {
+  sourceTXID: '123abc...',
+  sourceOutputIndex: 0,
+  sequence: 0xFFFFFFFF
+};
 
-An object literal set request's headers.
+// Using an unlocking script template
+txInput.unlockingScriptTemplate = {
+  sign: async (tx, index) => { ... },
+  estimateLength: async (tx, index) => { ... }
+};
+```
 
 ```ts
-headers?: Record<string, string>
+export default interface TransactionInput {
+    sourceTransaction?: Transaction;
+    sourceTXID?: string;
+    sourceOutputIndex: number;
+    unlockingScript?: UnlockingScript;
+    unlockingScriptTemplate?: {
+        sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>;
+        estimateLength: (tx: Transaction, inputIndex: number) => Promise<number>;
+    };
+    sequence?: number;
+}
 ```
 
-#### Property method
+See also: [Transaction](#class-transaction), [UnlockingScript](#class-unlockingscript), [sign](#variable-sign)
 
-A string to set request's method.
-
-```ts
-method?: string
-```
-
-</details>
-
-Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
+Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
 ---
-### Interface: ArcConfig
-
-Configuration options for the ARC broadcaster.
-
-```ts
-export interface ArcConfig {
-    apiKey?: string;
-    httpClient?: HttpClient;
-    deploymentId?: string;
-    callbackUrl?: string;
-    callbackToken?: string;
-    headers?: Record<string, string>;
-}
-```
-
-<details>
-
-<summary>Interface ArcConfig Details</summary>
-
-#### Property apiKey
-
-Authentication token for the ARC API
-
-```ts
-apiKey?: string
-```
-
-#### Property callbackToken
-
-default access token for notification callback endpoint. It will be used as a Authorization header for the http callback
-
-```ts
-callbackToken?: string
-```
-
-#### Property callbackUrl
-
-notification callback endpoint for proofs and double spend notification
-
-```ts
-callbackUrl?: string
-```
-
-#### Property deploymentId
-
-Deployment id used annotating api calls in XDeployment-ID header - this value will be randomly generated if not set
-
-```ts
-deploymentId?: string
-```
+### Interface: TransactionOutput
 
-#### Property headers
+Represents an output in a Bitcoin transaction.
+This interface defines the structure and components necessary to construct
+a transaction output, which secures owned Bitcoins to be unlocked later.
 
-additional headers to be attached to all tx submissions.
+Example
 
 ```ts
-headers?: Record<string, string>
+// Creating a simple transaction output
+let txOutput = {
+  satoshis: 1000,
+  lockingScript: LockingScript.fromASM('OP_DUP OP_HASH160 ... OP_EQUALVERIFY OP_CHECKSIG'),
+  change: false
+};
 ```
 
-#### Property httpClient
-
-The HTTP client used to make requests to the ARC API.
-
 ```ts
-httpClient?: HttpClient
+export default interface TransactionOutput {
+    satoshis?: number;
+    lockingScript: LockingScript;
+    change?: boolean;
+}
 ```
 
-</details>
+See also: [LockingScript](#class-lockingscript)
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
@@ -419,6 +435,8 @@ export interface WhatsOnChainConfig {
 }
 ```
 
+See also: [HttpClient](#interface-httpclient)
+
 <details>
 
 <summary>Interface WhatsOnChainConfig Details</summary>
@@ -438,6 +456,7 @@ The HTTP client used to make requests to the API.
 ```ts
 httpClient?: HttpClient
 ```
+See also: [HttpClient](#interface-httpclient)
 
 </details>
 
@@ -463,807 +482,935 @@ Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](
 
 ---
 
-### Class: SatoshisPerKilobyte
+### Class: ARC
 
-Represents the "satoshis per kilobyte" transaction fee model.
+Represents an ARC transaction broadcaster.
 
 ```ts
-export default class SatoshisPerKilobyte implements FeeModel {
-    value: number;
-    constructor(value: number) 
-    async computeFee(tx: Transaction): Promise<number> 
+export default class ARC implements Broadcaster {
+    readonly URL: string;
+    readonly apiKey: string | undefined;
+    readonly deploymentId: string;
+    readonly callbackUrl: string | undefined;
+    readonly callbackToken: string | undefined;
+    readonly headers: Record<string, string> | undefined;
+    constructor(URL: string, config?: ArcConfig);
+    constructor(URL: string, apiKey?: string);
+    constructor(URL: string, config?: string | ArcConfig) 
+    async broadcast(tx: Transaction): Promise<BroadcastResponse | BroadcastFailure> 
 }
 ```
 
+See also: [ArcConfig](#interface-arcconfig), [BroadcastFailure](#interface-broadcastfailure), [BroadcastResponse](#interface-broadcastresponse), [Broadcaster](#interface-broadcaster), [Transaction](#class-transaction)
+
 <details>
 
-<summary>Class SatoshisPerKilobyte Details</summary>
+<summary>Class ARC Details</summary>
 
 #### Constructor
 
-Constructs an instance of the sat/kb fee model.
+Constructs an instance of the ARC broadcaster.
 
 ```ts
-constructor(value: number) 
+constructor(URL: string, config?: ArcConfig)
 ```
+See also: [ArcConfig](#interface-arcconfig)
 
 Argument Details
 
-+ **value**
-  + The number of satoshis per kilobyte to charge as a fee.
++ **URL**
+  + The URL endpoint for the ARC API.
++ **config**
+  + Configuration options for the ARC broadcaster.
 
-#### Method computeFee
+#### Constructor
 
-Computes the fee for a given transaction.
+Constructs an instance of the ARC broadcaster.
 
 ```ts
-async computeFee(tx: Transaction): Promise<number> 
+constructor(URL: string, apiKey?: string)
+```
+
+Argument Details
+
++ **URL**
+  + The URL endpoint for the ARC API.
++ **apiKey**
+  + The API key used for authorization with the ARC API.
+
+#### Method broadcast
+
+Broadcasts a transaction via ARC.
+
+```ts
+async broadcast(tx: Transaction): Promise<BroadcastResponse | BroadcastFailure> 
 ```
+See also: [BroadcastFailure](#interface-broadcastfailure), [BroadcastResponse](#interface-broadcastresponse), [Transaction](#class-transaction)
 
 Returns
 
-The fee in satoshis for the transaction, as a BigNumber.
+A promise that resolves to either a success or failure response.
 
 Argument Details
 
 + **tx**
-  + The transaction for which a fee is to be computed.
+  + The transaction to be broadcasted.
 
 </details>
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
 ---
-### Class: MerklePath
-
-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.
-
-Example
-
-```ts
-// Creating and verifying a Merkle Path
-const merklePath = MerklePath.fromHex('...');
-const isValid = merklePath.verify(txid, chainTracker);
-```
+### Class: Beef
 
 ```ts
-export default class MerklePath {
-    blockHeight: number;
-    path: Array<Array<{
-        offset: number;
-        hash?: string;
-        txid?: boolean;
-        duplicate?: boolean;
-    }>>;
-    static fromHex(hex: string): MerklePath 
-    static fromReader(reader: Reader): MerklePath 
-    static fromBinary(bump: number[]): MerklePath 
-    constructor(blockHeight: number, path: Array<Array<{
-        offset: number;
-        hash?: string;
-        txid?: boolean;
-        duplicate?: boolean;
-    }>>) 
+export class Beef {
+    bumps: MerklePath[] = [];
+    txs: BeefTx[] = [];
+    version: BeefVersion = undefined;
+    atomicTxid: string | undefined = undefined;
+    constructor(version?: BeefVersion) 
+    get magic(): number 
+    findTxid(txid: string): BeefTx | undefined 
+    findBump(txid: string): MerklePath | undefined 
+    findTransactionForSigning(txid: string): Transaction | undefined 
+    findAtomicTransaction(txid: string): Transaction | undefined 
+    mergeBump(bump: MerklePath): number 
+    mergeRawTx(rawTx: number[], bumpIndex?: number): BeefTx 
+    mergeTransaction(tx: Transaction): BeefTx 
+    removeExistingTxid(txid: string) 
+    mergeTxidOnly(txid: string): BeefTx 
+    mergeBeefTx(btx: BeefTx): BeefTx 
+    mergeBeef(beef: number[] | Beef) 
+    isValid(allowTxidOnly?: boolean): boolean 
+    async verify(chainTracker: ChainTracker, allowTxidOnly?: boolean): Promise<boolean> 
+    toWriter(writer: Writer) 
     toBinary(): number[] 
+    toBinaryAtomic(txid: string) 
     toHex(): string 
-    computeRoot(txid?: string): string 
-    findOrComputeLeaf(height: number, offset: number): MerklePathLeaf | undefined 
-    async verify(txid: string, chainTracker: ChainTracker): Promise<boolean> 
-    combine(other: MerklePath): void 
-    trim() 
+    static fromReader(br: Reader): Beef 
+    static fromBinary(bin: number[]): Beef 
+    static fromString(s: string, enc?: "hex" | "utf8" | "base64"): Beef 
+    sortTxs(): {
+        missingInputs: string[];
+        notValid: string[];
+        valid: string[];
+        withMissingInputs: string[];
+        txidOnly: string[];
+    } 
+    clone(): Beef 
+    trimKnownTxids(knownTxids: string[]) 
+    getValidTxids(): string[] 
+    toLogString(): string 
 }
 ```
 
-<details>
+See also: [BeefTx](#class-beeftx), [BeefVersion](#type-beefversion), [ChainTracker](#interface-chaintracker), [MerklePath](#class-merklepath), [Reader](#class-reader), [Transaction](#class-transaction), [Writer](#class-writer), [toHex](#variable-tohex), [verify](#variable-verify)
 
-<summary>Class MerklePath Details</summary>
+<details>
 
-#### Method combine
+<summary>Class Beef Details</summary>
 
-Combines this MerklePath with another to create a compound proof.
+#### Method clone
 
 ```ts
-combine(other: MerklePath): void 
+clone(): Beef 
 ```
+See also: [Beef](#class-beef)
 
-Argument Details
-
-+ **other**
-  + Another MerklePath to combine with this path.
+Returns
 
-Throws
+a shallow copy of this beef
 
-- If the paths have different block heights or roots.
+#### Method findAtomicTransaction
 
-#### Method computeRoot
+Builds the proof tree rooted at a specific `Transaction`.
 
-Computes the Merkle root from the provided transaction ID.
+To succeed, the Beef must contain all the required transaction and merkle path data.
 
 ```ts
-computeRoot(txid?: string): string 
+findAtomicTransaction(txid: string): Transaction | undefined 
 ```
+See also: [Transaction](#class-transaction)
 
 Returns
 
-- The computed Merkle root as a hexadecimal string.
+Transaction with input `SourceTransaction` and `MerklePath` populated from this Beef.
 
 Argument Details
 
 + **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!
-
-Throws
-
-- If the transaction ID is not part of the Merkle Path.
-
-#### Method findOrComputeLeaf
-
-Find leaf with `offset` at `height` or compute from level below, recursively.
+  + The id of the target transaction.
 
-Does not add computed leaves to path.
+#### Method findBump
 
 ```ts
-findOrComputeLeaf(height: number, offset: number): MerklePathLeaf | undefined 
+findBump(txid: string): MerklePath | undefined 
 ```
+See also: [MerklePath](#class-merklepath)
 
-#### Method fromBinary
+Returns
 
-Creates a MerklePath instance from a binary array.
+`MerklePath` with level zero hash equal to txid or undefined.
+
+#### Method findTransactionForSigning
+
+Finds a Transaction in this `Beef`
+and adds any missing input SourceTransactions from this `Beef`.
+
+The result is suitable for signing.
 
 ```ts
-static fromBinary(bump: number[]): MerklePath 
+findTransactionForSigning(txid: string): Transaction | undefined 
 ```
+See also: [Transaction](#class-transaction)
 
 Returns
 
-- A new MerklePath instance.
+Transaction with all available input `SourceTransaction`s from this Beef.
 
 Argument Details
 
-+ **bump**
-  + The binary array representation of the Merkle Path.
++ **txid**
+  + The id of the target transaction.
 
-#### Method fromHex
+#### Method findTxid
 
-Creates a MerklePath instance from a hexadecimal string.
+```ts
+findTxid(txid: string): BeefTx | undefined 
+```
+See also: [BeefTx](#class-beeftx)
+
+Returns
+
+`BeefTx` in `txs` with `txid`.
+
+Argument Details
+
++ **txid**
+  + of `beefTx` to find
+
+#### Method fromBinary
+
+Constructs an instance of the Beef class based on the provided binary array
 
 ```ts
-static fromHex(hex: string): MerklePath 
+static fromBinary(bin: number[]): Beef 
 ```
+See also: [Beef](#class-beef)
 
 Returns
 
-- A new MerklePath instance.
+An instance of the Beef class constructed from the binary data
 
 Argument Details
 
-+ **hex**
-  + The hexadecimal string representation of the Merkle Path.
++ **bin**
+  + The binary array from which to construct BEEF
 
-#### Method toBinary
+#### Method fromString
 
-Converts the MerklePath to a binary array format.
+Constructs an instance of the Beef class based on the provided string
 
 ```ts
-toBinary(): number[] 
+static fromString(s: string, enc?: "hex" | "utf8" | "base64"): Beef 
 ```
+See also: [Beef](#class-beef)
 
 Returns
 
-- The binary array representation of the Merkle Path.
+An instance of the Beef class constructed from the string
 
-#### Method toHex
+Argument Details
 
-Converts the MerklePath to a hexadecimal string format.
++ **s**
+  + The string value from which to construct BEEF
++ **enc**
+  + The encoding of the string value from which BEEF should be constructed
+
+#### Method getValidTxids
 
 ```ts
-toHex(): string 
+getValidTxids(): string[] 
 ```
 
 Returns
 
-- The hexadecimal string representation of the Merkle Path.
+array of transaction txids that either have a proof or whose inputs chain back to a proven transaction.
 
-#### Method trim
+#### Method isValid
 
-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.
+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.
 
 ```ts
-trim() 
+isValid(allowTxidOnly?: boolean): boolean 
 ```
 
-#### Method verify
+Argument Details
 
-Verifies if the given transaction ID is part of the Merkle tree at the specified block height.
++ **allowTxidOnly**
+  + optional. If true, transaction txid only is assumed valid
+
+#### Method mergeBump
+
+Merge a MerklePath that is assumed to be fully valid.
 
 ```ts
-async verify(txid: string, chainTracker: ChainTracker): Promise<boolean> 
+mergeBump(bump: MerklePath): number 
 ```
+See also: [MerklePath](#class-merklepath)
 
 Returns
 
-- True if the transaction ID is valid within the Merkle Path at the specified block height.
+index of merged bump
+
+#### Method mergeRawTx
+
+Merge a serialized transaction.
+
+Checks that a transaction with the same txid hasn't already been merged.
+
+Replaces existing transaction with same txid.
+
+```ts
+mergeRawTx(rawTx: number[], bumpIndex?: number): BeefTx 
+```
+See also: [BeefTx](#class-beeftx)
+
+Returns
+
+txid of rawTx
 
 Argument Details
 
-+ **txid**
-  + The transaction ID to verify.
-+ **chainTracker**
-  + The ChainTracker instance used to verify the Merkle root.
++ **bumpIndex**
+  + Optional. If a number, must be valid index into bumps array.
 
-</details>
+#### Method mergeTransaction
 
-Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
+Merge a `Transaction` and any referenced `merklePath` and `sourceTransaction`, recursifely.
 
----
-### Class: NodejsHttpClient
+Replaces existing transaction with same txid.
 
-Adapter for Node.js Https module to be used as HttpClient
+Attempts to match an existing bump to the new transaction.
 
 ```ts
-export class NodejsHttpClient implements HttpClient {
-    constructor(private readonly https: HttpsNodejs) 
-    async request(url: string, requestOptions: HttpClientRequestOptions): Promise<HttpClientResponse> 
-}
+mergeTransaction(tx: Transaction): BeefTx 
 ```
+See also: [BeefTx](#class-beeftx), [Transaction](#class-transaction)
 
-Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
+Returns
 
----
-### Class: FetchHttpClient
+txid of tx
 
-Adapter for Node.js Https module to be used as HttpClient
+#### Method removeExistingTxid
+
+Removes an existing transaction from the BEEF, given its TXID
 
 ```ts
-export class FetchHttpClient implements HttpClient {
-    constructor(private readonly fetch: Fetch) 
-    async request<D>(url: string, options: HttpClientRequestOptions): Promise<HttpClientResponse<D>> 
-}
+removeExistingTxid(txid: string) 
 ```
 
-Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
+Argument Details
 
----
-### Class: ARC
++ **txid**
+  + TXID of the transaction to remove
 
-Represents an ARC transaction broadcaster.
+#### Method sortTxs
+
+Sort the `txs` by input txid dependency order:
+- Oldest Tx Anchored by Path
+- Newer Txs depending on Older parents
+- Newest Tx
+
+with proof (MerklePath) last, longest chain of dependencies first
 
 ```ts
-export default class ARC implements Broadcaster {
-    readonly URL: string;
-    readonly apiKey: string | undefined;
-    readonly deploymentId: string;
-    readonly callbackUrl: string | undefined;
-    readonly callbackToken: string | undefined;
-    readonly headers: Record<string, string> | undefined;
-    constructor(URL: string, config?: ArcConfig);
-    constructor(URL: string, apiKey?: string);
-    constructor(URL: string, config?: string | ArcConfig) 
-    async broadcast(tx: Transaction): Promise<BroadcastResponse | BroadcastFailure> 
-}
+sortTxs(): {
+    missingInputs: string[];
+    notValid: string[];
+    valid: string[];
+    withMissingInputs: string[];
+    txidOnly: string[];
+} 
 ```
 
-<details>
+Returns
 
-<summary>Class ARC Details</summary>
+`{ missingInputs, notValid, valid, withMissingInputs }`
 
-#### Constructor
+#### Method toBinary
 
-Constructs an instance of the ARC broadcaster.
+Returns a binary array representing the serialized BEEF
 
 ```ts
-constructor(URL: string, config?: ArcConfig)
+toBinary(): number[] 
 ```
 
-Argument Details
+Returns
 
-+ **URL**
-  + The URL endpoint for the ARC API.
-+ **config**
-  + Configuration options for the ARC broadcaster.
+A binary array representing the BEEF
 
-#### Constructor
+#### Method toBinaryAtomic
 
-Constructs an instance of the ARC broadcaster.
+Serialize this Beef as AtomicBEEF.
+
+`txid` must exist and be the last transaction
+in sorted (dependency) order.
 
 ```ts
-constructor(URL: string, apiKey?: string)
+toBinaryAtomic(txid: string) 
 ```
 
-Argument Details
+Returns
 
-+ **URL**
-  + The URL endpoint for the ARC API.
-+ **apiKey**
-  + The API key used for authorization with the ARC API.
+serialized contents of this Beef with AtomicBEEF prefix.
 
-#### Method broadcast
+#### Method toHex
 
-Broadcasts a transaction via ARC.
+Returns a hex string representing the serialized BEEF
 
 ```ts
-async broadcast(tx: Transaction): Promise<BroadcastResponse | BroadcastFailure> 
+toHex(): string 
 ```
 
 Returns
 
-A promise that resolves to either a success or failure response.
+A hex string representing the BEEF
 
-Argument Details
+#### Method toLogString
 
-+ **tx**
-  + The transaction to be broadcasted.
+```ts
+toLogString(): string 
+```
 
-</details>
+Returns
 
-Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
+Summary of `Beef` contents as multi-line string.
 
----
-### Class: WhatsOnChain
+#### Method toWriter
 
-Represents a chain tracker based on What's On Chain .
+Serializes this data to `writer`
 
 ```ts
-export default class WhatsOnChain implements ChainTracker {
-    readonly network: string;
-    readonly apiKey: string;
-    constructor(network: "main" | "test" | "stn" = "main", config: WhatsOnChainConfig = {}) 
-    async isValidRootForHeight(root: string, height: number): Promise<boolean> 
-}
+toWriter(writer: Writer) 
 ```
+See also: [Writer](#class-writer)
 
-<details>
+#### Method trimKnownTxids
 
-<summary>Class WhatsOnChain Details</summary>
+Ensure that all the txids in `knownTxids` are txidOnly
 
-#### Constructor
+```ts
+trimKnownTxids(knownTxids: string[]) 
+```
 
-Constructs an instance of the WhatsOnChain ChainTracker.
+#### Method verify
+
+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.
 
 ```ts
-constructor(network: "main" | "test" | "stn" = "main", config: WhatsOnChainConfig = {}) 
+async verify(chainTracker: ChainTracker, allowTxidOnly?: boolean): Promise<boolean> 
 ```
+See also: [ChainTracker](#interface-chaintracker)
 
 Argument Details
 
-+ **network**
-  + The BSV network to use when calling the WhatsOnChain API.
-+ **config**
-  + Configuration options for the WhatsOnChain ChainTracker.
++ **chainTracker**
+  + Used to verify computed merkle path roots for all bump txids.
++ **allowTxidOnly**
+  + optional. If true, transaction txid is assumed valid
 
 </details>
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
 ---
-### Class: BeefTx
+### Class: BeefParty
 
-A single bitcoin transaction associated with a `Beef` validity proof set.
+Extends `Beef` that is used to exchange transaction validity data with more than one external party.
 
-Simple case is transaction data included directly, either as raw bytes or fully parsed data, or both.
+Use `addKnownTxidsForParty` to keep track of who knows what to reduce re-transmission of potentially large transactions.
 
-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.
+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.
 
 ```ts
-export default class BeefTx {
-    _bumpIndex?: number;
-    _tx?: Transaction;
-    _rawTx?: number[];
-    _txid?: string;
-    inputTxids: string[] = [];
-    isValid?: boolean = undefined;
-    get bumpIndex(): number | undefined 
-    set bumpIndex(v: number | undefined) 
-    get hasProof(): boolean 
-    get isTxidOnly(): boolean 
-    get txid() 
-    get tx() 
-    get rawTx() 
-    constructor(tx: Transaction | number[] | string, bumpIndex?: number) 
-    toWriter(writer: Writer, magic: number): void 
-    static fromReader(br: Reader, magic: number): BeefTx 
+export class BeefParty extends Beef {
+    knownTo: Record<string, Record<string, boolean>> = {};
+    constructor(parties?: string[]) 
+    isParty(party: string) 
+    addParty(party: string) 
+    getKnownTxidsForParty(party: string): string[] 
+    getTrimmedBeefForParty(party: string): Beef 
+    addKnownTxidsForParty(party: string, knownTxids: string[]) 
+    mergeBeefFromParty(party: string, beef: number[] | Beef) 
 }
 ```
 
+See also: [Beef](#class-beef)
+
 <details>
 
-<summary>Class BeefTx Details</summary>
+<summary>Class BeefParty Details</summary>
 
 #### Constructor
 
 ```ts
-constructor(tx: Transaction | number[] | string, bumpIndex?: number) 
+constructor(parties?: string[]) 
 ```
 
 Argument Details
 
-+ **tx**
-  + If string, must be a valid txid. If `number[]` must be a valid serialized transaction.
-+ **bumpIndex**
-  + If transaction already has a proof in the beef to which it will be added.
++ **parties**
+  + Optional array of initial unique party identifiers.
 
-#### Property isValid
+#### Property knownTo
 
-true if `hasProof` or all inputs chain to `hasProof`.
+keys are party identifiers.
+values are records of txids with truthy value for which the party already has validity proof.
 
-Typically set by sorting transactions by proven dependency chains.
+```ts
+knownTo: Record<string, Record<string, boolean>> = {}
+```
+
+#### Method addKnownTxidsForParty
+
+Make note of additional txids "known" to `party`.
 
 ```ts
-isValid?: boolean = undefined
+addKnownTxidsForParty(party: string, knownTxids: string[]) 
 ```
 
-</details>
+Argument Details
 
-Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
++ **party**
+  + unique identifier, added if new.
 
----
-### Class: Beef
+#### Method addParty
+
+Adds a new unique party identifier to this `BeefParty`.
 
 ```ts
-export class Beef {
-    bumps: MerklePath[] = [];
-    txs: BeefTx[] = [];
-    version: BeefVersion = undefined;
-    atomicTxid: string | undefined = undefined;
-    constructor(version?: BeefVersion) 
-    get magic(): number 
-    findTxid(txid: string): BeefTx | undefined 
-    findBump(txid: string): MerklePath | undefined 
-    findTransactionForSigning(txid: string): Transaction | undefined 
-    findAtomicTransaction(txid: string): Transaction | undefined 
-    mergeBump(bump: MerklePath): number 
-    mergeRawTx(rawTx: number[], bumpIndex?: number): BeefTx 
-    mergeTransaction(tx: Transaction): BeefTx 
-    removeExistingTxid(txid: string) 
-    mergeTxidOnly(txid: string): BeefTx 
-    mergeBeefTx(btx: BeefTx): BeefTx 
-    mergeBeef(beef: number[] | Beef) 
-    isValid(allowTxidOnly?: boolean): boolean 
-    async verify(chainTracker: ChainTracker, allowTxidOnly?: boolean): Promise<boolean> 
-    toWriter(writer: Writer) 
-    toBinary(): number[] 
-    toBinaryAtomic(txid: string) 
-    toHex(): string 
-    static fromReader(br: Reader): Beef 
-    static fromBinary(bin: number[]): Beef 
-    static fromString(s: string, enc?: "hex" | "utf8" | "base64"): Beef 
-    sortTxs(): {
-        missingInputs: string[];
-        notValid: string[];
-        valid: string[];
-        withMissingInputs: string[];
-        txidOnly: string[];
-    } 
-    clone(): Beef 
-    trimKnownTxids(knownTxids: string[]) 
-    getValidTxids(): string[] 
-    toLogString(): string 
-}
+addParty(party: string) 
 ```
 
-<details>
+#### Method getKnownTxidsForParty
 
-<summary>Class Beef Details</summary>
+```ts
+getKnownTxidsForParty(party: string): string[] 
+```
 
-#### Method clone
+Returns
+
+Array of txids "known" to `party`.
+
+#### Method getTrimmedBeefForParty
 
 ```ts
-clone(): Beef 
+getTrimmedBeefForParty(party: string): Beef 
 ```
+See also: [Beef](#class-beef)
 
 Returns
 
-a shallow copy of this beef
+trimmed beef of unknown transactions and proofs for `party`
+
+#### Method isParty
+
+```ts
+isParty(party: string) 
+```
+
+Returns
+
+`true` if `party` has already beed added to this `BeefParty`.
+
+#### Method mergeBeefFromParty
+
+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.
+
+```ts
+mergeBeefFromParty(party: string, beef: number[] | Beef) 
+```
+See also: [Beef](#class-beef)
+
+</details>
+
+Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
+
+---
+### Class: BeefTx
+
+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.
+
+```ts
+export default class BeefTx {
+    _bumpIndex?: number;
+    _tx?: Transaction;
+    _rawTx?: number[];
+    _txid?: string;
+    inputTxids: string[] = [];
+    isValid?: boolean = undefined;
+    get bumpIndex(): number | undefined 
+    set bumpIndex(v: number | undefined) 
+    get hasProof(): boolean 
+    get isTxidOnly(): boolean 
+    get txid() 
+    get tx() 
+    get rawTx() 
+    constructor(tx: Transaction | number[] | string, bumpIndex?: number) 
+    toWriter(writer: Writer, magic: number): void 
+    static fromReader(br: Reader, magic: number): BeefTx 
+}
+```
+
+See also: [Reader](#class-reader), [Transaction](#class-transaction), [Writer](#class-writer)
 
-#### Method findAtomicTransaction
+<details>
 
-Builds the proof tree rooted at a specific `Transaction`.
+<summary>Class BeefTx Details</summary>
 
-To succeed, the Beef must contain all the required transaction and merkle path data.
+#### Constructor
 
 ```ts
-findAtomicTransaction(txid: string): Transaction | undefined 
+constructor(tx: Transaction | number[] | string, bumpIndex?: number) 
 ```
+See also: [Transaction](#class-transaction)
 
-Returns
+Argument Details
 
-Transaction with input `SourceTransaction` and `MerklePath` populated from this Beef.
++ **tx**
+  + If string, must be a valid txid. If `number[]` must be a valid serialized transaction.
++ **bumpIndex**
+  + If transaction already has a proof in the beef to which it will be added.
 
-Argument Details
+#### Property isValid
 
-+ **txid**
-  + The id of the target transaction.
+true if `hasProof` or all inputs chain to `hasProof`.
 
-#### Method findBump
+Typically set by sorting transactions by proven dependency chains.
 
 ```ts
-findBump(txid: string): MerklePath | undefined 
+isValid?: boolean = undefined
 ```
 
-Returns
-
-`MerklePath` with level zero hash equal to txid or undefined.
+</details>
 
-#### Method findTransactionForSigning
+Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
-Finds a Transaction in this `Beef`
-and adds any missing input SourceTransactions from this `Beef`.
+---
+### Class: FetchHttpClient
 
-The result is suitable for signing.
+Adapter for Node.js Https module to be used as HttpClient
 
 ```ts
-findTransactionForSigning(txid: string): Transaction | undefined 
+export class FetchHttpClient implements HttpClient {
+    constructor(private readonly fetch: Fetch) 
+    async request<D>(url: string, options: HttpClientRequestOptions): Promise<HttpClientResponse<D>> 
+}
 ```
 
-Returns
+See also: [Fetch](#type-fetch), [HttpClient](#interface-httpclient), [HttpClientRequestOptions](#interface-httpclientrequestoptions), [HttpClientResponse](#type-httpclientresponse)
 
-Transaction with all available input `SourceTransaction`s from this Beef.
+Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
-Argument Details
+---
+### Class: MerklePath
 
-+ **txid**
-  + The id of the target transaction.
+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.
 
-#### Method findTxid
+Example
 
 ```ts
-findTxid(txid: string): BeefTx | undefined 
+// Creating and verifying a Merkle Path
+const merklePath = MerklePath.fromHex('...');
+const isValid = merklePath.verify(txid, chainTracker);
 ```
 
-Returns
+```ts
+export default class MerklePath {
+    blockHeight: number;
+    path: Array<Array<{
+        offset: number;
+        hash?: string;
+        txid?: boolean;
+        duplicate?: boolean;
+    }>>;
+    static fromHex(hex: string): MerklePath 
+    static fromReader(reader: Reader): MerklePath 
+    static fromBinary(bump: number[]): MerklePath 
+    constructor(blockHeight: number, path: Array<Array<{
+        offset: number;
+        hash?: string;
+        txid?: boolean;
+        duplicate?: boolean;
+    }>>) 
+    toBinary(): number[] 
+    toHex(): string 
+    computeRoot(txid?: string): string 
+    findOrComputeLeaf(height: number, offset: number): MerklePathLeaf | undefined 
+    async verify(txid: string, chainTracker: ChainTracker): Promise<boolean> 
+    combine(other: MerklePath): void 
+    trim() 
+}
+```
 
-`BeefTx` in `txs` with `txid`.
+See also: [ChainTracker](#interface-chaintracker), [MerklePathLeaf](#interface-merklepathleaf), [Reader](#class-reader), [toHex](#variable-tohex), [verify](#variable-verify)
 
-Argument Details
+<details>
 
-+ **txid**
-  + of `beefTx` to find
+<summary>Class MerklePath Details</summary>
 
-#### Method fromBinary
+#### Method combine
 
-Constructs an instance of the Beef class based on the provided binary array
+Combines this MerklePath with another to create a compound proof.
 
 ```ts
-static fromBinary(bin: number[]): Beef 
+combine(other: MerklePath): void 
 ```
+See also: [MerklePath](#class-merklepath)
 
-Returns
+Argument Details
 
-An instance of the Beef class constructed from the binary data
++ **other**
+  + Another MerklePath to combine with this path.
 
-Argument Details
+Throws
 
-+ **bin**
-  + The binary array from which to construct BEEF
+- If the paths have different block heights or roots.
 
-#### Method fromString
+#### Method computeRoot
 
-Constructs an instance of the Beef class based on the provided string
+Computes the Merkle root from the provided transaction ID.
 
 ```ts
-static fromString(s: string, enc?: "hex" | "utf8" | "base64"): Beef 
+computeRoot(txid?: string): string 
 ```
 
 Returns
 
-An instance of the Beef class constructed from the string
+- The computed Merkle root as a hexadecimal string.
 
 Argument Details
 
-+ **s**
-  + The string value from which to construct BEEF
-+ **enc**
-  + The encoding of the string value from which BEEF should be constructed
-
-#### Method getValidTxids
-
-```ts
-getValidTxids(): string[] 
-```
-
-Returns
++ **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!
 
-array of transaction txids that either have a proof or whose inputs chain back to a proven transaction.
+Throws
 
-#### Method isValid
+- If the transaction ID is not part of the Merkle Path.
 
-Sorts `txs` and checks structural validity of beef.
+#### Method findOrComputeLeaf
 
-Does NOT verify merkle roots.
+Find leaf with `offset` at `height` or compute from level below, recursively.
 
-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.
+Does not add computed leaves to path.
 
 ```ts
-isValid(allowTxidOnly?: boolean): boolean 
+findOrComputeLeaf(height: number, offset: number): MerklePathLeaf | undefined 
 ```
+See also: [MerklePathLeaf](#interface-merklepathleaf)
 
-Argument Details
-
-+ **allowTxidOnly**
-  + optional. If true, transaction txid only is assumed valid
-
-#### Method mergeBump
+#### Method fromBinary
 
-Merge a MerklePath that is assumed to be fully valid.
+Creates a MerklePath instance from a binary array.
 
 ```ts
-mergeBump(bump: MerklePath): number 
+static fromBinary(bump: number[]): MerklePath 
 ```
+See also: [MerklePath](#class-merklepath)
 
 Returns
 
-index of merged bump
+- A new MerklePath instance.
 
-#### Method mergeRawTx
+Argument Details
 
-Merge a serialized transaction.
++ **bump**
+  + The binary array representation of the Merkle Path.
 
-Checks that a transaction with the same txid hasn't already been merged.
+#### Method fromHex
 
-Replaces existing transaction with same txid.
+Creates a MerklePath instance from a hexadecimal string.
 
 ```ts
-mergeRawTx(rawTx: number[], bumpIndex?: number): BeefTx 
+static fromHex(hex: string): MerklePath 
 ```
+See also: [MerklePath](#class-merklepath)
 
 Returns
 
-txid of rawTx
+- A new MerklePath instance.
 
 Argument Details
 
-+ **bumpIndex**
-  + Optional. If a number, must be valid index into bumps array.
-
-#### Method mergeTransaction
-
-Merge a `Transaction` and any referenced `merklePath` and `sourceTransaction`, recursifely.
++ **hex**
+  + The hexadecimal string representation of the Merkle Path.
 
-Replaces existing transaction with same txid.
+#### Method toBinary
 
-Attempts to match an existing bump to the new transaction.
+Converts the MerklePath to a binary array format.
 
 ```ts
-mergeTransaction(tx: Transaction): BeefTx 
+toBinary(): number[] 
 ```
 
 Returns
 
-txid of tx
-
-#### Method removeExistingTxid
-
-Removes an existing transaction from the BEEF, given its TXID
-
-```ts
-removeExistingTxid(txid: string) 
-```
-
-Argument Details
-
-+ **txid**
-  + TXID of the transaction to remove
-
-#### Method sortTxs
+- The binary array representation of the Merkle Path.
 
-Sort the `txs` by input txid dependency order:
-- Oldest Tx Anchored by Path
-- Newer Txs depending on Older parents
-- Newest Tx
+#### Method toHex
 
-with proof (MerklePath) last, longest chain of dependencies first
+Converts the MerklePath to a hexadecimal string format.
 
 ```ts
-sortTxs(): {
-    missingInputs: string[];
-    notValid: string[];
-    valid: string[];
-    withMissingInputs: string[];
-    txidOnly: string[];
-} 
+toHex(): string 
 ```
 
 Returns
 
-`{ missingInputs, notValid, valid, withMissingInputs }`
+- The hexadecimal string representation of the Merkle Path.
 
-#### Method toBinary
+#### Method trim
 
-Returns a binary array representing the serialized BEEF
+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.
 
 ```ts
-toBinary(): number[] 
+trim() 
 ```
 
-Returns
-
-A binary array representing the BEEF
-
-#### Method toBinaryAtomic
-
-Serialize this Beef as AtomicBEEF.
+#### Method verify
 
-`txid` must exist and be the last transaction
-in sorted (dependency) order.
+Verifies if the given transaction ID is part of the Merkle tree at the specified block height.
 
 ```ts
-toBinaryAtomic(txid: string) 
+async verify(txid: string, chainTracker: ChainTracker): Promise<boolean> 
 ```
+See also: [ChainTracker](#interface-chaintracker)
 
 Returns
 
-serialized contents of this Beef with AtomicBEEF prefix.
+- True if the transaction ID is valid within the Merkle Path at the specified block height.
 
-#### Method toHex
+Argument Details
 
-Returns a hex string representing the serialized BEEF
++ **txid**
+  + The transaction ID to verify.
++ **chainTracker**
+  + The ChainTracker instance used to verify the Merkle root.
 
-```ts
-toHex(): string 
-```
+</details>
 
-Returns
+Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
-A hex string representing the BEEF
+---
+### Class: NodejsHttpClient
 
-#### Method toLogString
+Adapter for Node.js Https module to be used as HttpClient
 
 ```ts
-toLogString(): string 
+export class NodejsHttpClient implements HttpClient {
+    constructor(private readonly https: HttpsNodejs) 
+    async request(url: string, requestOptions: HttpClientRequestOptions): Promise<HttpClientResponse> 
+}
 ```
 
-Returns
+See also: [HttpClient](#interface-httpclient), [HttpClientRequestOptions](#interface-httpclientrequestoptions), [HttpClientResponse](#type-httpclientresponse), [HttpsNodejs](#interface-httpsnodejs)
 
-Summary of `Beef` contents as multi-line string.
+Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
-#### Method toWriter
+---
+### Class: SatoshisPerKilobyte
 
-Serializes this data to `writer`
+Represents the "satoshis per kilobyte" transaction fee model.
 
 ```ts
-toWriter(writer: Writer) 
+export default class SatoshisPerKilobyte implements FeeModel {
+    value: number;
+    constructor(value: number) 
+    async computeFee(tx: Transaction): Promise<number> 
+}
 ```
 
-#### Method trimKnownTxids
+See also: [FeeModel](#interface-feemodel), [Transaction](#class-transaction)
 
-Ensure that all the txids in `knownTxids` are txidOnly
+<details>
+
+<summary>Class SatoshisPerKilobyte Details</summary>
+
+#### Constructor
+
+Constructs an instance of the sat/kb fee model.
 
 ```ts
-trimKnownTxids(knownTxids: string[]) 
+constructor(value: number) 
 ```
 
-#### Method verify
+Argument Details
 
-Sorts `txs` and confirms validity of transaction data contained in beef
-by validating structure of this beef and confirming computed merkle roots
-using `chainTracker`.
++ **value**
+  + The number of satoshis per kilobyte to charge as a fee.
 
-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.
+#### Method computeFee
+
+Computes the fee for a given transaction.
 
 ```ts
-async verify(chainTracker: ChainTracker, allowTxidOnly?: boolean): Promise<boolean> 
+async computeFee(tx: Transaction): Promise<number> 
 ```
+See also: [Transaction](#class-transaction)
+
+Returns
+
+The fee in satoshis for the transaction, as a BigNumber.
 
 Argument Details
 
-+ **chainTracker**
-  + Used to verify computed merkle path roots for all bump txids.
-+ **allowTxidOnly**
-  + optional. If true, transaction txid is assumed valid
++ **tx**
+  + The transaction for which a fee is to be computed.
 
 </details>
 
@@ -1340,6 +1487,8 @@ export default class Transaction {
 }
 ```
 
+See also: [BroadcastFailure](#interface-broadcastfailure), [BroadcastResponse](#interface-broadcastresponse), [Broadcaster](#interface-broadcaster), [ChainTracker](#interface-chaintracker), [FeeModel](#interface-feemodel), [MerklePath](#class-merklepath), [Reader](#class-reader), [TransactionInput](#interface-transactioninput), [TransactionOutput](#interface-transactionoutput), [defaultBroadcaster](#function-defaultbroadcaster), [defaultChainTracker](#function-defaultchaintracker), [sign](#variable-sign), [toHex](#variable-tohex), [verify](#variable-verify)
+
 <details>
 
 <summary>Class Transaction Details</summary>
@@ -1351,6 +1500,7 @@ Adds a new input to the transaction.
 ```ts
 addInput(input: TransactionInput): void 
 ```
+See also: [TransactionInput](#interface-transactioninput)
 
 Argument Details
 
@@ -1368,6 +1518,7 @@ Adds a new output to the transaction.
 ```ts
 addOutput(output: TransactionOutput): void 
 ```
+See also: [TransactionOutput](#interface-transactionoutput)
 
 Argument Details
 
@@ -1381,6 +1532,7 @@ Broadcasts a transaction.
 ```ts
 async broadcast(broadcaster: Broadcaster = defaultBroadcaster()): Promise<BroadcastResponse | BroadcastFailure> 
 ```
+See also: [BroadcastFailure](#interface-broadcastfailure), [BroadcastResponse](#interface-broadcastresponse), [Broadcaster](#interface-broadcaster), [defaultBroadcaster](#function-defaultbroadcaster)
 
 Returns
 
@@ -1400,6 +1552,7 @@ If fee is a number, the transaction uses that value as fee.
 ```ts
 async fee(modelOrFee?: FeeModel | number, changeDistribution: "equal" | "random" = "equal"): Promise<void> 
 ```
+See also: [FeeModel](#interface-feemodel)
 
 Argument Details
 
@@ -1421,6 +1574,7 @@ Throws errors if the Atomic BEEF data does not strictly adhere to the BRC-95 spe
 ```ts
 static fromAtomicBEEF(beef: number[]): Transaction 
 ```
+See also: [Transaction](#class-transaction)
 
 Returns
 
@@ -1441,6 +1595,7 @@ If no TXID is provided, the last transaction in the BEEF data is returned.
 ```ts
 static fromBEEF(beef: number[], txid?: string): Transaction 
 ```
+See also: [Transaction](#class-transaction)
 
 Returns
 
@@ -1460,6 +1615,7 @@ Creates a Transaction instance from a binary array.
 ```ts
 static fromBinary(bin: number[]): Transaction 
 ```
+See also: [Transaction](#class-transaction)
 
 Returns
 
@@ -1477,6 +1633,7 @@ Creates a new transaction, linked to its inputs and their associated merkle path
 ```ts
 static fromEF(ef: number[]): Transaction 
 ```
+See also: [Transaction](#class-transaction)
 
 Returns
 
@@ -1494,6 +1651,7 @@ Creates a Transaction instance from a hexadecimal string.
 ```ts
 static fromHex(hex: string): Transaction 
 ```
+See also: [Transaction](#class-transaction)
 
 Returns
 
@@ -1514,6 +1672,7 @@ If no TXID is provided, the last transaction in the BEEF data is returned.
 ```ts
 static fromHexBEEF(hex: string, txid?: string): Transaction 
 ```
+See also: [Transaction](#class-transaction)
 
 Returns
 
@@ -1533,6 +1692,7 @@ Creates a Transaction instance from a hexadecimal string encoded EF.
 ```ts
 static fromHexEF(hex: string): Transaction 
 ```
+See also: [Transaction](#class-transaction)
 
 Returns
 
@@ -1799,6 +1959,7 @@ Verifies the legitimacy of the Bitcoin transaction according to the rules of SPV
 ```ts
 async verify(chainTracker: ChainTracker | "scripts only" = defaultChainTracker(), feeModel?: FeeModel): Promise<boolean> 
 ```
+See also: [ChainTracker](#interface-chaintracker), [FeeModel](#interface-feemodel), [defaultChainTracker](#function-defaultchaintracker)
 
 Returns
 
@@ -1820,126 +1981,40 @@ tx.verify(new WhatsOnChain(), new SatoshisPerKilobyte(1))
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
 ---
-### Class: BeefParty
-
-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.
+### Class: WhatsOnChain
 
-The size and redundancy of these Beefs becomes a problem when chained transaction creation out-paces the block mining rate.
+Represents a chain tracker based on What's On Chain .
 
 ```ts
-export class BeefParty extends Beef {
-    knownTo: Record<string, Record<string, boolean>> = {};
-    constructor(parties?: string[]) 
-    isParty(party: string) 
-    addParty(party: string) 
-    getKnownTxidsForParty(party: string): string[] 
-    getTrimmedBeefForParty(party: string): Beef 
-    addKnownTxidsForParty(party: string, knownTxids: string[]) 
-    mergeBeefFromParty(party: string, beef: number[] | Beef) 
+export default class WhatsOnChain implements ChainTracker {
+    readonly network: string;
+    readonly apiKey: string;
+    constructor(network: "main" | "test" | "stn" = "main", config: WhatsOnChainConfig = {}) 
+    async isValidRootForHeight(root: string, height: number): Promise<boolean> 
 }
 ```
 
+See also: [ChainTracker](#interface-chaintracker), [WhatsOnChainConfig](#interface-whatsonchainconfig)
+
 <details>
 
-<summary>Class BeefParty Details</summary>
+<summary>Class WhatsOnChain Details</summary>
 
 #### Constructor
 
-```ts
-constructor(parties?: string[]) 
-```
-
-Argument Details
-
-+ **parties**
-  + Optional array of initial unique party identifiers.
-
-#### Property knownTo
-
-keys are party identifiers.
-values are records of txids with truthy value for which the party already has validity proof.
-
-```ts
-knownTo: Record<string, Record<string, boolean>> = {}
-```
-
-#### Method addKnownTxidsForParty
-
-Make note of additional txids "known" to `party`.
+Constructs an instance of the WhatsOnChain ChainTracker.
 
 ```ts
-addKnownTxidsForParty(party: string, knownTxids: string[]) 
+constructor(network: "main" | "test" | "stn" = "main", config: WhatsOnChainConfig = {}) 
 ```
+See also: [WhatsOnChainConfig](#interface-whatsonchainconfig)
 
 Argument Details
 
-+ **party**
-  + unique identifier, added if new.
-
-#### Method addParty
-
-Adds a new unique party identifier to this `BeefParty`.
-
-```ts
-addParty(party: string) 
-```
-
-#### Method getKnownTxidsForParty
-
-```ts
-getKnownTxidsForParty(party: string): string[] 
-```
-
-Returns
-
-Array of txids "known" to `party`.
-
-#### Method getTrimmedBeefForParty
-
-```ts
-getTrimmedBeefForParty(party: string): Beef 
-```
-
-Returns
-
-trimmed beef of unknown transactions and proofs for `party`
-
-#### Method isParty
-
-```ts
-isParty(party: string) 
-```
-
-Returns
-
-`true` if `party` has already beed added to this `BeefParty`.
-
-#### Method mergeBeefFromParty
-
-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.
-
-```ts
-mergeBeefFromParty(party: string, beef: number[] | Beef) 
-```
++ **network**
+  + The BSV network to use when calling the WhatsOnChain API.
++ **config**
+  + Configuration options for the WhatsOnChain ChainTracker.
 
 </details>
 
@@ -1960,25 +2035,25 @@ Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](
 
 ---
 
-### Function: isBroadcastResponse
-
-Convenience type guard for response from `Broadcaster.broadcast`
+### Function: defaultBroadcaster
 
 ```ts
-export function isBroadcastResponse(r: BroadcastResponse | BroadcastFailure): r is BroadcastResponse 
+export function defaultBroadcaster(): Broadcaster 
 ```
 
+See also: [Broadcaster](#interface-broadcaster)
+
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
 ---
-### Function: isBroadcastFailure
-
-Convenience type guard for response from `Broadcaster.broadcast`
+### Function: defaultChainTracker
 
 ```ts
-export function isBroadcastFailure(r: BroadcastResponse | BroadcastFailure): r is BroadcastFailure 
+export function defaultChainTracker(): ChainTracker 
 ```
 
+See also: [ChainTracker](#interface-chaintracker)
+
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
 ---
@@ -1992,24 +2067,34 @@ If running in a Node.js environment, it falls back to using the Node.js `https`
 export function defaultHttpClient(): HttpClient 
 ```
 
+See also: [HttpClient](#interface-httpclient)
+
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
 ---
-### Function: defaultBroadcaster
+### Function: isBroadcastFailure
+
+Convenience type guard for response from `Broadcaster.broadcast`
 
 ```ts
-export function defaultBroadcaster(): Broadcaster 
+export function isBroadcastFailure(r: BroadcastResponse | BroadcastFailure): r is BroadcastFailure 
 ```
 
+See also: [BroadcastFailure](#interface-broadcastfailure), [BroadcastResponse](#interface-broadcastresponse)
+
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
 ---
-### Function: defaultChainTracker
+### Function: isBroadcastResponse
+
+Convenience type guard for response from `Broadcaster.broadcast`
 
 ```ts
-export function defaultChainTracker(): ChainTracker 
+export function isBroadcastResponse(r: BroadcastResponse | BroadcastFailure): r is BroadcastResponse 
 ```
 
+See also: [BroadcastFailure](#interface-broadcastfailure), [BroadcastResponse](#interface-broadcastresponse)
+
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
 ---
@@ -2025,22 +2110,10 @@ Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](
 
 ---
 
-### Type: HttpClientResponse
-
-An interface for the response returned by the request method.
+### Type: BeefVersion
 
 ```ts
-export type HttpClientResponse<T = any> = {
-    data: T;
-    status: number;
-    statusText: string;
-    ok: true;
-} | {
-    data: any;
-    status: number;
-    statusText: string;
-    ok: false;
-}
+export type BeefVersion = undefined | "V1" | "V2"
 ```
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
@@ -2056,13 +2129,27 @@ Makes a request to the server.
 export type Fetch = (url: string, options: FetchOptions) => Promise<Response>
 ```
 
+See also: [FetchOptions](#interface-fetchoptions)
+
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
 ---
-### Type: BeefVersion
+### Type: HttpClientResponse
+
+An interface for the response returned by the request method.
 
 ```ts
-export type BeefVersion = undefined | "V1" | "V2"
+export type HttpClientResponse<T = any> = {
+    data: T;
+    status: number;
+    statusText: string;
+    ok: true;
+} | {
+    data: any;
+    status: number;
+    statusText: string;
+    ok: false;
+}
 ```
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
@@ -2081,19 +2168,19 @@ Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](
 
 ---
 
-### Variable: BEEF_MAGIC
+### Variable: ATOMIC_BEEF
 
 ```ts
-BEEF_MAGIC = 4022206465
+ATOMIC_BEEF = 16843009
 ```
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
 ---
-### Variable: BEEF_MAGIC_V2
+### Variable: BEEF_MAGIC
 
 ```ts
-BEEF_MAGIC_V2 = 4022206466
+BEEF_MAGIC = 4022206465
 ```
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
@@ -2108,10 +2195,10 @@ BEEF_MAGIC_TXID_ONLY_EXTENSION = 4022206465
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
 ---
-### Variable: ATOMIC_BEEF
+### Variable: BEEF_MAGIC_V2
 
 ```ts
-ATOMIC_BEEF = 16843009
+BEEF_MAGIC_V2 = 4022206466
 ```
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)