@bsv/sdk 1.6.4 → 1.6.6

package/docs/kvstore.md

@@ -14,7 +14,8 @@ Allows setting, getting, and removing key-value pairs, with optional encryption.
 
 ```ts
 export default class LocalKVStore {
-    constructor(wallet: WalletInterface = new WalletClient(), context = "kvstore default", encrypt = true, originator?: string) 
+    acceptDelayedBroadcast: boolean = false;
+    constructor(wallet: WalletInterface = new WalletClient(), context = "kvstore default", encrypt = true, originator?: string, acceptDelayedBroadcast = false) 
     async get(key: string, defaultValue: string | undefined = undefined): Promise<string | undefined> 
     async set(key: string, value: string): Promise<OutpointString> 
     async remove(key: string): Promise<string[]> 
@@ -28,7 +29,7 @@ See also: [OutpointString](./wallet.md#type-outpointstring), [WalletClient](./wa
 Creates an instance of the localKVStore.
 
 ```ts
-constructor(wallet: WalletInterface = new WalletClient(), context = "kvstore default", encrypt = true, originator?: string) 
+constructor(wallet: WalletInterface = new WalletClient(), context = "kvstore default", encrypt = true, originator?: string, acceptDelayedBroadcast = false) 
 ```
 See also: [WalletClient](./wallet.md#class-walletclient), [WalletInterface](./wallet.md#interface-walletinterface), [encrypt](./messages.md#variable-encrypt)
 
@@ -96,13 +97,15 @@ Argument Details
 
 #### Method set
 
-Sets or updates the value associated with a given key.
+Sets or updates the value associated with a given key atomically.
 If the key already exists (one or more outputs found), it spends the existing output(s)
 and creates a new one with the updated value. If multiple outputs exist for the key,
 they are collapsed into a single new output.
 If the key does not exist, it creates a new output.
 Handles encryption if enabled.
 If signing the update/collapse transaction fails, it relinquishes the original outputs and starts over with a new chain.
+Ensures atomicity by locking the key during the operation, preventing concurrent updates
+to the same key from missing earlier changes.
 
 ```ts
 async set(key: string, value: string): Promise<OutpointString> 

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/storage.md

@@ -120,8 +120,6 @@ Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](
 
 ### Class: StorageDownloader
 
-Locates HTTP URLs where content can be downloaded. It uses the passed or the default one.
-
 ```ts
 export class StorageDownloader {
     constructor(config?: DownloaderConfig) 
@@ -132,6 +130,41 @@ export class StorageDownloader {
 
 See also: [DownloadResult](./storage.md#interface-downloadresult), [DownloaderConfig](./storage.md#interface-downloaderconfig)
 
+#### Method download
+
+Downloads the content from the UHRP URL after validating the hash for integrity.
+
+```ts
+public async download(uhrpUrl: string): Promise<DownloadResult> 
+```
+See also: [DownloadResult](./storage.md#interface-downloadresult)
+
+Returns
+
+A promise that resolves to the downloaded content.
+
+Argument Details
+
++ **uhrpUrl**
+  + The UHRP URL to download.
+
+#### Method resolve
+
+Resolves the UHRP URL to a list of HTTP URLs where content can be downloaded.
+
+```ts
+public async resolve(uhrpUrl: string): Promise<string[]> 
+```
+
+Returns
+
+A promise that resolves to an array of HTTP URLs.
+
+Argument Details
+
++ **uhrpUrl**
+  + The UHRP URL to resolve.
+
 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.4",
+  "version": "1.6.6",
   "type": "module",
   "description": "BSV Blockchain Software Development Kit",
   "main": "dist/cjs/mod.js",

package/src/kvstore/LocalKVStore.ts

@@ -38,6 +38,14 @@ export default class LocalKVStore {
    */
   private readonly originator?: string
 
+  acceptDelayedBroadcast: boolean = false
+
+  /**
+   * A map to store locks for each key to ensure atomic updates.
+   * @private
+   */
+  private readonly keyLocks: Map<string, Promise<void>> = new Map()
+
   /**
    * Creates an instance of the localKVStore.
    *
@@ -51,7 +59,8 @@ export default class LocalKVStore {
     wallet: WalletInterface = new WalletClient(),
     context = 'kvstore default',
     encrypt = true,
-    originator?: string
+    originator?: string,
+    acceptDelayedBroadcast = false
   ) {
     if (typeof context !== 'string' || context.length < 1) {
       throw new Error('A context in which to operate is required.')
@@ -60,6 +69,7 @@ export default class LocalKVStore {
     this.context = context
     this.encrypt = encrypt
     this.originator = originator
+    this.acceptDelayedBroadcast = acceptDelayedBroadcast
   }
 
   private getProtocol (key: string): { protocolID: WalletProtocol, keyID: string } {
@@ -160,78 +170,106 @@ export default class LocalKVStore {
   }
 
   /**
-   * Sets or updates the value associated with a given key.
+   * Sets or updates the value associated with a given key atomically.
    * If the key already exists (one or more outputs found), it spends the existing output(s)
    * and creates a new one with the updated value. If multiple outputs exist for the key,
    * they are collapsed into a single new output.
    * If the key does not exist, it creates a new output.
    * Handles encryption if enabled.
    * If signing the update/collapse transaction fails, it relinquishes the original outputs and starts over with a new chain.
+   * Ensures atomicity by locking the key during the operation, preventing concurrent updates
+   * to the same key from missing earlier changes.
    *
    * @param {string} key - The key to set or update.
    * @param {string} value - The value to associate with the key.
    * @returns {Promise<OutpointString>} A promise that resolves to the outpoint string (txid.vout) of the new or updated token output.
    */
   async set (key: string, value: string): Promise<OutpointString> {
-    const current = await this.lookupValue(key, undefined, 10)
-    if (current.value === value) {
-      if (current.outpoint === undefined) { throw new Error('outpoint must be valid when value is valid and unchanged') }
-      // Don't create a new transaction if the value doesn't need to change...
-      return current.outpoint
-    }
-    const protocol = this.getProtocol(key)
-    let valueAsArray = Utils.toArray(value, 'utf8')
-    if (this.encrypt) {
-      const { ciphertext } = await this.wallet.encrypt({
-        ...protocol,
-        plaintext: valueAsArray
-      })
-      valueAsArray = ciphertext
+    // Check if a lock exists for this key and wait for it to resolve
+    const existingLock = this.keyLocks.get(key)
+    if (existingLock != null) {
+      await existingLock
     }
-    const pushdrop = new PushDrop(this.wallet, this.originator)
-    const lockingScript = await pushdrop.lock(
-      [valueAsArray],
-      protocol.protocolID,
-      protocol.keyID,
-      'self'
-    )
-    const { outputs, BEEF: inputBEEF } = current.lor
-    let outpoint: OutpointString
+
+    let resolveNewLock: () => void = () => {}
+    const newLock = new Promise<void>((resolve) => {
+      resolveNewLock = resolve
+    })
+    this.keyLocks.set(key, newLock)
+
     try {
-      const inputs = this.getInputs(outputs)
-      const { txid, signableTransaction } = await this.wallet.createAction({
-        description: `Update ${key} in ${this.context}`,
-        inputBEEF,
-        inputs,
-        outputs: [{
-          basket: this.context,
-          tags: [key],
-          lockingScript: lockingScript.toHex(),
-          satoshis: 1,
-          outputDescription: 'Key-value token'
-        }],
-        options: {
-          acceptDelayedBroadcast: false,
-          randomizeOutputs: false
+      const current = await this.lookupValue(key, undefined, 10)
+      if (current.value === value) {
+        if (current.outpoint === undefined) {
+          throw new Error('outpoint must be valid when value is valid and unchanged')
         }
-      })
-      if (outputs.length > 0 && typeof signableTransaction !== 'object') {
-        throw new Error('Wallet did not return a signable transaction when expected.')
+        // Don't create a new transaction if the value doesn't need to change
+        return current.outpoint
       }
-      if (signableTransaction == null) {
-        outpoint = `${txid as string}.0`
-      } else {
-        const spends = await this.getSpends(key, outputs, pushdrop, signableTransaction.tx)
-        const { txid } = await this.wallet.signAction({
-          reference: signableTransaction.reference,
-          spends
+
+      const protocol = this.getProtocol(key)
+      let valueAsArray = Utils.toArray(value, 'utf8')
+      if (this.encrypt) {
+        const { ciphertext } = await this.wallet.encrypt({
+          ...protocol,
+          plaintext: valueAsArray
         })
-        outpoint = `${txid as string}.0`
+        valueAsArray = ciphertext
       }
-    } catch (_) {
-      throw new Error(`There are ${outputs.length} outputs with tag ${key} that cannot be unlocked.`)
+
+      const pushdrop = new PushDrop(this.wallet, this.originator)
+      const lockingScript = await pushdrop.lock(
+        [valueAsArray],
+        protocol.protocolID,
+        protocol.keyID,
+        'self'
+      )
+
+      const { outputs, BEEF: inputBEEF } = current.lor
+      let outpoint: OutpointString
+      try {
+        const inputs = this.getInputs(outputs)
+        const { txid, signableTransaction } = await this.wallet.createAction({
+          description: `Update ${key} in ${this.context}`,
+          inputBEEF,
+          inputs,
+          outputs: [{
+            basket: this.context,
+            tags: [key],
+            lockingScript: lockingScript.toHex(),
+            satoshis: 1,
+            outputDescription: 'Key-value token'
+          }],
+          options: {
+            acceptDelayedBroadcast: this.acceptDelayedBroadcast,
+            randomizeOutputs: false
+          }
+        })
+
+        if (outputs.length > 0 && typeof signableTransaction !== 'object') {
+          throw new Error('Wallet did not return a signable transaction when expected.')
+        }
+
+        if (signableTransaction == null) {
+          outpoint = `${txid as string}.0`
+        } else {
+          const spends = await this.getSpends(key, outputs, pushdrop, signableTransaction.tx)
+          const { txid } = await this.wallet.signAction({
+            reference: signableTransaction.reference,
+            spends
+          })
+          outpoint = `${txid as string}.0`
+        }
+      } catch (_) {
+        throw new Error(`There are ${outputs.length} outputs with tag ${key} that cannot be unlocked.`)
+      }
+
+      return outpoint
+    } finally {
+      // Release the lock by resolving the promise and removing it from the map
+      this.keyLocks.delete(key)
+      resolveNewLock()
     }
-    return outpoint
   }
 
   /**
@@ -257,7 +295,7 @@ export default class LocalKVStore {
             inputBEEF,
             inputs,
             options: {
-              acceptDelayedBroadcast: false
+              acceptDelayedBroadcast: this.acceptDelayedBroadcast
             }
           })
           if (typeof signableTransaction !== 'object') {

package/src/storage/StorageDownloader.ts

@@ -13,17 +13,6 @@ export interface DownloadResult {
   mimeType: string | null
 }
 
-/**
- * Locates HTTP URLs where content can be downloaded. It uses the passed or the default one.
- *
- * @param {Object} obj All parameters are passed in an object.
- * @param {String} obj.uhrpUrl The UHRP url to resolve.
- * @param {string} obj.confederacyHost HTTPS URL for for the with default setting.
- *
- * @return {Array<String>} An array of HTTP URLs where content can be downloaded.
- * @throws {Error} If UHRP url parameter invalid or is not an array
- * or there is an error retrieving url(s) stored in the UHRP token.
- */
 export class StorageDownloader {
   private readonly networkPreset?: 'mainnet' | 'testnet' | 'local' = 'mainnet'
 
@@ -31,6 +20,11 @@ export class StorageDownloader {
     this.networkPreset = config?.networkPreset
   }
 
+  /**
+   * Resolves the UHRP URL to a list of HTTP URLs where content can be downloaded.
+   * @param uhrpUrl The UHRP URL to resolve.
+   * @returns A promise that resolves to an array of HTTP URLs.
+   */
   public async resolve (uhrpUrl: string): Promise<string[]> {
     // Use UHRP lookup service
     const lookupResolver = new LookupResolver({ networkPreset: this.networkPreset })
@@ -54,6 +48,11 @@ export class StorageDownloader {
     return decodedResults
   }
 
+  /**
+   * Downloads the content from the UHRP URL after validating the hash for integrity.
+   * @param uhrpUrl The UHRP URL to download.
+   * @returns A promise that resolves to the downloaded content.
+   */
   public async download (uhrpUrl: string): Promise<DownloadResult> {
     if (!StorageUtils.isValidURL(uhrpUrl)) {
       throw new Error('Invalid parameter UHRP url')

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'