@bsv/sdk 1.6.3 → 1.6.5

package/docs/overlay-tools.md

@@ -272,6 +272,7 @@ Tagged BEEF
 export interface TaggedBEEF {
     beef: number[];
     topics: string[];
+    offChainValues?: number[];
 }
 ```
 
@@ -530,10 +531,8 @@ export type LookupAnswer = {
     outputs: Array<{
         beef: number[];
         outputIndex: number;
+        context?: number[];
     }>;
-} | {
-    type: "freeform";
-    result: unknown;
 }
 ```
 

package/docs/primitives.md

@@ -93,8 +93,7 @@ export default class BigNumber {
     zeroBits(): number 
     byteLength(): number { if (this._magnitude === 0n)
         return 0; return Math.ceil(this.bitLength() / 8); }
-    toTwos(width: number): BigNumber { this.assert(width >= 0); const Bw = BigInt(width); let v = this._getSignedValue(); if (this._sign === 1 && this._magnitude !== 0n)
-        v = (1n << Bw) + v; const m = (1n << Bw) - 1n; v &= m; const r = new BigNumber(0n); r._initializeState(v, 0); return r; }
+    toTwos(width: number): BigNumber 
     fromTwos(width: number): BigNumber 
     isNeg(): boolean 
     neg(): BigNumber 
@@ -132,15 +131,7 @@ export default class BigNumber {
     iushln(bits: number): this { this.assert(typeof bits === "number" && bits >= 0); if (bits === 0)
         return this; this._magnitude <<= BigInt(bits); this._finishInitialization(); return this.strip(); }
     ishln(bits: number): this 
-    iushrn(bits: number, hint?: number, extended?: BigNumber): this { this.assert(typeof bits === "number" && bits >= 0); if (bits === 0) {
-        if (extended != null)
-            extended._initializeState(0n, 0);
-        return this;
-    } if (extended != null) {
-        const m = (1n << BigInt(bits)) - 1n;
-        const sOut = this._magnitude & m;
-        extended._initializeState(sOut, 0);
-    } this._magnitude >>= BigInt(bits); this._finishInitialization(); return this.strip(); }
+    iushrn(bits: number, hint?: number, extended?: BigNumber): this 
     ishrn(bits: number, hint?: number, extended?: BigNumber): this 
     shln(bits: number): BigNumber 
     ushln(bits: number): BigNumber 
@@ -168,31 +159,8 @@ export default class BigNumber {
         a: BigNumber;
         b: BigNumber;
         gcd: BigNumber;
-    } { this.assert(p._sign === 0, "p must not be negative"); this.assert(!p.isZero(), "p must not be zero"); let uV = this._getSignedValue(); let vV = p._magnitude; let a = 1n; let pa = 0n; let b = 0n; let pb = 1n; while (vV !== 0n) {
-        const q = uV / vV;
-        let t = vV;
-        vV = uV % vV;
-        uV = t;
-        t = pa;
-        pa = a - q * pa;
-        a = t;
-        t = pb;
-        pb = b - q * pb;
-        b = t;
-    } const ra = new BigNumber(0n); ra._setValueFromSigned(a); const rb = new BigNumber(0n); rb._setValueFromSigned(b); const rg = new BigNumber(0n); rg._initializeState(uV < 0n ? -uV : uV, 0); return { a: ra, b: rb, gcd: rg }; }
-    gcd(num: BigNumber): BigNumber { let u = this._magnitude; let v = num._magnitude; if (u === 0n) {
-        const r = new BigNumber(0n);
-        r._setValueFromSigned(v);
-        return r.iabs();
-    } if (v === 0n) {
-        const r = new BigNumber(0n);
-        r._setValueFromSigned(u);
-        return r.iabs();
-    } while (v !== 0n) {
-        const t = u % v;
-        u = v;
-        v = t;
-    } const res = new BigNumber(0n); res._initializeState(u, 0); return res; }
+    } 
+    gcd(num: BigNumber): BigNumber 
     invm(num: BigNumber): BigNumber 
     isEven(): boolean 
     isOdd(): boolean 
@@ -3247,8 +3215,8 @@ export class Reader {
     public pos: number;
     constructor(bin: number[] = [], pos: number = 0) 
     public eof(): boolean 
-    public read(len = this.bin.length): number[] 
-    public readReverse(len = this.bin.length): number[] 
+    public read(len = this.length): number[] 
+    public readReverse(len = this.length): number[] 
     public readUInt8(): number 
     public readInt8(): number 
     public readUInt16BE(): number 
@@ -5047,9 +5015,9 @@ Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](
 
 ```ts
 exclusiveOR = function (block0: number[], block1: number[]): number[] {
-    let i;
-    const result = [];
-    for (i = 0; i < block0.length; i++) {
+    const len = block0.length;
+    const result = new Array(len);
+    for (let i = 0; i < len; i++) {
         result[i] = block0[i] ^ block1[i];
     }
     return result;
@@ -5231,20 +5199,19 @@ Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](
 
 ```ts
 multiply = function (block0: number[], block1: number[]): number[] {
-    let i;
-    let j;
-    let v = block1.slice();
-    let z = createZeroBlock(16);
-    for (i = 0; i < 16; i++) {
-        for (j = 7; j !== -1; j--) {
-            if (checkBit(block0, i, j) !== 0) {
-                z = exclusiveOR(z, v);
+    const v = block1.slice();
+    const z = createZeroBlock(16);
+    for (let i = 0; i < 16; i++) {
+        for (let j = 7; j >= 0; j--) {
+            if ((block0[i] & (1 << j)) !== 0) {
+                xorInto(z, v);
             }
-            if (checkBit(v, 15, 0) !== 0) {
-                v = exclusiveOR(rightShift(v), R);
+            if ((v[15] & 1) !== 0) {
+                rightShift(v);
+                xorInto(v, R);
             }
             else {
-                v = rightShift(v);
+                rightShift(v);
             }
         }
     }
@@ -5252,7 +5219,7 @@ multiply = function (block0: number[], block1: number[]): number[] {
 }
 ```
 
-See also: [checkBit](./primitives.md#variable-checkbit), [exclusiveOR](./primitives.md#variable-exclusiveor), [rightShift](./primitives.md#variable-rightshift)
+See also: [rightShift](./primitives.md#variable-rightshift)
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Enums](#enums), [Variables](#variables)
 

package/docs/transaction.md

@@ -1506,7 +1506,7 @@ export default class Transaction {
     static fromHex(hex: string): Transaction 
     static fromHexEF(hex: string): Transaction 
     static fromHexBEEF(hex: string, txid?: string): Transaction 
-    constructor(version: number = 1, inputs: TransactionInput[] = [], outputs: TransactionOutput[] = [], lockTime: number = 0, metadata: Record<string, any> = {}, merklePath?: MerklePath) 
+    constructor(version: number = 1, inputs: TransactionInput[] = [], outputs: TransactionOutput[] = [], lockTime: number = 0, metadata: Record<string, any> = new Map(), merklePath?: MerklePath) 
     addInput(input: TransactionInput): void 
     addOutput(output: TransactionOutput): void 
     addP2PKHOutput(address: number[] | string, satoshis?: number): void 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/sdk",
-  "version": "1.6.3",
+  "version": "1.6.5",
   "type": "module",
   "description": "BSV Blockchain Software Development Kit",
   "main": "dist/cjs/mod.js",

package/src/script/index.ts

@@ -6,3 +6,4 @@ export { default as Spend } from './Spend.js'
 export type { default as ScriptTemplateUnlock } from './ScriptTemplateUnlock.js'
 export type { default as ScriptTemplate } from './ScriptTemplate.js'
 export * from './templates/index.js'
+export type { default as ScriptChunk } from './ScriptChunk.js'

package/src/transaction/chaintrackers/BlockHeadersService.ts

@@ -0,0 +1,138 @@
+import ChainTracker from '../ChainTracker.js'
+import { HttpClient } from '../http/HttpClient.js'
+import { defaultHttpClient } from '../http/DefaultHttpClient.js'
+
+/** Configuration options for the BlockHeadersService ChainTracker. */
+export interface BlockHeadersServiceConfig {
+  /** The HTTP client used to make requests to the API. */
+  httpClient?: HttpClient
+
+  /** The API key used to authenticate requests to the BlockHeadersService API. */
+  apiKey?: string
+}
+
+interface MerkleRootVerificationRequest {
+  blockHeight: number
+  merkleRoot: string
+}
+
+interface MerkleRootConfirmation {
+  blockHash: string
+  blockHeight: number
+  merkleRoot: string
+  confirmation: 'CONFIRMED' | 'UNCONFIRMED'
+}
+
+interface MerkleRootVerificationResponse {
+  confirmationState: 'CONFIRMED' | 'UNCONFIRMED'
+  confirmations: MerkleRootConfirmation[]
+}
+
+/**
+ * Represents a chain tracker based on a BlockHeadersService API.
+ * 
+ * @example
+ * ```typescript
+ * const chainTracker = new BlockHeadersService('https://headers.spv.money', {
+ *   apiKey: '17JxRHcJerGBEbusx56W8o1m8Js73TFGo'
+ * })
+ * ```
+ */
+export class BlockHeadersService implements ChainTracker {
+  protected readonly baseUrl: string
+  protected readonly httpClient: HttpClient
+  protected readonly apiKey: string
+
+  /**
+   * Constructs an instance of the BlockHeadersService ChainTracker.
+   * 
+   * @param {string} baseUrl - The base URL for the BlockHeadersService API (e.g. https://headers.spv.money)
+   * @param {BlockHeadersServiceConfig} config - Configuration options for the BlockHeadersService ChainTracker.
+   */
+  constructor(
+    baseUrl: string,
+    config: BlockHeadersServiceConfig = {}
+  ) {
+    const { httpClient, apiKey } = config
+    this.baseUrl = baseUrl
+    this.httpClient = httpClient ?? defaultHttpClient()
+    this.apiKey = apiKey ?? ''
+  }
+
+  /**
+   * Verifies if a given merkle root is valid for a specific block height.
+   * 
+   * @param {string} root - The merkle root to verify.
+   * @param {number} height - The block height to check against.
+   * @returns {Promise<boolean>} - A promise that resolves to true if the merkle root is valid for the specified block height, false otherwise.
+   */
+  async isValidRootForHeight(root: string, height: number): Promise<boolean> {
+    const requestOptions = {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+        'Authorization': `Bearer ${this.apiKey}`
+      },
+      data: [
+        {
+          blockHeight: height,
+          merkleRoot: root
+        }
+      ] as MerkleRootVerificationRequest[]
+    }
+
+    try {
+      const response = await this.httpClient.request<MerkleRootVerificationResponse>(
+        `${this.baseUrl}/api/v1/chain/merkleroot/verify`,
+        requestOptions
+      )
+
+      if (response.ok) {        
+        return response.data.confirmationState === 'CONFIRMED'
+      } else {
+        throw new Error(
+          `Failed to verify merkleroot for height ${height} because of an error: ${JSON.stringify(response.data)}`
+        )
+      }
+    } catch (error) {
+      throw new Error(
+        `Failed to verify merkleroot for height ${height} because of an error: ${error instanceof Error ? error.message : String(error)}`
+      )
+    }
+  }
+
+  /**
+   * Gets the current block height from the BlockHeadersService API.
+   * 
+   * @returns {Promise<number>} - A promise that resolves to the current block height.
+   */
+  async currentHeight(): Promise<number> {
+    const requestOptions = {
+      method: 'GET',
+      headers: {
+        'Accept': 'application/json',
+        'Authorization': `Bearer ${this.apiKey}`
+      }
+    }
+
+    try {
+      const response = await this.httpClient.request<{ height: number }>(
+        `${this.baseUrl}/api/v1/chain/tip/longest`,
+        requestOptions
+      )
+      
+      if (response.ok && response.data && typeof response.data.height === 'number') {
+        return response.data.height
+      } else {
+        throw new Error(
+          `Failed to get current height because of an error: ${JSON.stringify(response.data)}`
+        )
+      }
+    } catch (error) {
+      throw new Error(
+        `Failed to get current height because of an error: ${error instanceof Error ? error.message : String(error)}`
+      )
+    }
+  }
+}

package/src/transaction/chaintrackers/index.ts

@@ -1,3 +1,4 @@
 export { default as WhatsOnChain } from './WhatsOnChain.js'
 export type { WhatsOnChainConfig } from './WhatsOnChain.js'
+export { BlockHeadersService } from './BlockHeadersService.js'
 export { defaultChainTracker } from './DefaultChainTracker.js'