@bsv/sdk 1.6.6 → 1.6.8

package/docs/primitives.md

@@ -3229,7 +3229,8 @@ export class Reader {
     public readInt32LE(): number 
     public readUInt64BEBn(): BigNumber 
     public readUInt64LEBn(): BigNumber 
-    public readVarIntNum(): number 
+    public readInt64LEBn(): BigNumber 
+    public readVarIntNum(signed: boolean = true): number 
     public readVarInt(): number[] 
     public readVarIntBn(): BigNumber 
 }

package/package.json

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

package/src/kvstore/LocalKVStore.ts

@@ -44,7 +44,7 @@ export default class LocalKVStore {
    * A map to store locks for each key to ensure atomic updates.
    * @private
    */
-  private readonly keyLocks: Map<string, Promise<void>> = new Map()
+  private readonly keyLocks: Map<string, Array<(value: void | PromiseLike<void>) => void>> = new Map()
 
   /**
    * Creates an instance of the localKVStore.
@@ -72,6 +72,38 @@ export default class LocalKVStore {
     this.acceptDelayedBroadcast = acceptDelayedBroadcast
   }
 
+  private async queueOperationOnKey (key: string): Promise<Array<(value: void | PromiseLike<void>) => void>> {
+    // Check if a lock exists for this key and wait for it to resolve
+    let lockQueue = this.keyLocks.get(key)
+    if (lockQueue == null) {
+      lockQueue = []
+      this.keyLocks.set(key, lockQueue)
+    }
+
+    let resolveNewLock: () => void = () => {}
+    const newLock = new Promise<void>((resolve) => {
+      resolveNewLock = resolve
+      if (lockQueue != null) { lockQueue.push(resolve) }
+    })
+
+    // If we are the only request, resolve the lock immediately, queue remains at 1 item until request ends.
+    if (lockQueue.length === 1) {
+      resolveNewLock()
+    }
+
+    await newLock
+
+    return lockQueue
+  }
+
+  private finishOperationOnKey (key: string, lockQueue: Array<(value: void | PromiseLike<void>) => void>): void {
+    lockQueue.shift() // Remove the current lock from the queue
+    if (lockQueue.length > 0) {
+      // If there are more locks waiting, resolve the next one
+      lockQueue[0]()
+    }
+  }
+
   private getProtocol (key: string): { protocolID: WalletProtocol, keyID: string } {
     return { protocolID: [2, this.context], keyID: key }
   }
@@ -98,8 +130,14 @@ export default class LocalKVStore {
    * @throws {Error} If the found output's locking script cannot be decoded or represents an invalid token format.
    */
   async get (key: string, defaultValue: string | undefined = undefined): Promise<string | undefined> {
-    const r = await this.lookupValue(key, defaultValue, 5)
-    return r.value
+    const lockQueue = await this.queueOperationOnKey(key)
+
+    try {
+      const r = await this.lookupValue(key, defaultValue, 5)
+      return r.value
+    } finally {
+      this.finishOperationOnKey(key, lockQueue)
+    }
   }
 
   private getLockingScript (output: WalletOutput, beef: Beef): LockingScript {
@@ -185,17 +223,7 @@ export default class LocalKVStore {
    * @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> {
-    // 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
-    }
-
-    let resolveNewLock: () => void = () => {}
-    const newLock = new Promise<void>((resolve) => {
-      resolveNewLock = resolve
-    })
-    this.keyLocks.set(key, newLock)
+    const lockQueue = await this.queueOperationOnKey(key)
 
     try {
       const current = await this.lookupValue(key, undefined, 10)
@@ -266,9 +294,7 @@ export default class LocalKVStore {
 
       return outpoint
     } finally {
-      // Release the lock by resolving the promise and removing it from the map
-      this.keyLocks.delete(key)
-      resolveNewLock()
+      this.finishOperationOnKey(key, lockQueue)
     }
   }
 
@@ -283,38 +309,44 @@ export default class LocalKVStore {
    * @returns {Promise<string[]>} A promise that resolves to the txids of the removal transactions if successful.
    */
   async remove (key: string): Promise<string[]> {
-    const txids: string[] = []
-    for (; ;) {
-      const { outputs, BEEF: inputBEEF, totalOutputs } = await this.getOutputs(key)
-      if (outputs.length > 0) {
-        const pushdrop = new PushDrop(this.wallet, this.originator)
-        try {
-          const inputs = this.getInputs(outputs)
-          const { signableTransaction } = await this.wallet.createAction({
-            description: `Remove ${key} in ${this.context}`,
-            inputBEEF,
-            inputs,
-            options: {
-              acceptDelayedBroadcast: this.acceptDelayedBroadcast
+    const lockQueue = await this.queueOperationOnKey(key)
+
+    try {
+      const txids: string[] = []
+      for (; ;) {
+        const { outputs, BEEF: inputBEEF, totalOutputs } = await this.getOutputs(key)
+        if (outputs.length > 0) {
+          const pushdrop = new PushDrop(this.wallet, this.originator)
+          try {
+            const inputs = this.getInputs(outputs)
+            const { signableTransaction } = await this.wallet.createAction({
+              description: `Remove ${key} in ${this.context}`,
+              inputBEEF,
+              inputs,
+              options: {
+                acceptDelayedBroadcast: this.acceptDelayedBroadcast
+              }
+            })
+            if (typeof signableTransaction !== 'object') {
+              throw new Error('Wallet did not return a signable transaction when expected.')
             }
-          })
-          if (typeof signableTransaction !== 'object') {
-            throw new Error('Wallet did not return a signable transaction when expected.')
+            const spends = await this.getSpends(key, outputs, pushdrop, signableTransaction.tx)
+            const { txid } = await this.wallet.signAction({
+              reference: signableTransaction.reference,
+              spends
+            })
+            if (txid === undefined) { throw new Error('signAction must return a valid txid') }
+            txids.push(txid)
+          } catch (_) {
+            throw new Error(`There are ${totalOutputs} outputs with tag ${key} that cannot be unlocked.`)
           }
-          const spends = await this.getSpends(key, outputs, pushdrop, signableTransaction.tx)
-          const { txid } = await this.wallet.signAction({
-            reference: signableTransaction.reference,
-            spends
-          })
-          if (txid === undefined) { throw new Error('signAction must return a valid txid') }
-          txids.push(txid)
-        } catch (_) {
-          throw new Error(`There are ${totalOutputs} outputs with tag ${key} that cannot be unlocked.`)
         }
+        if (outputs.length === totalOutputs) { break }
       }
-      if (outputs.length === totalOutputs) { break }
+      return txids
+    } finally {
+      this.finishOperationOnKey(key, lockQueue)
     }
-    return txids
   }
 }
 

package/src/primitives/utils.ts

@@ -525,6 +525,9 @@ export class Writer {
 
   static varIntNum (n: number): number[] {
     let buf: number[]
+    if (n < 0) {
+      return this.varIntBn(new BigNumber(n))
+    }
     if (n < 253) {
       buf = [n] // 1 byte
     } else if (n < 0x10000) {
@@ -565,6 +568,9 @@ export class Writer {
 
   static varIntBn (bn: BigNumber): number[] {
     let buf: number[]
+    if (bn.isNeg()) {
+      bn = bn.add(OverflowUint64) // Adjust for negative numbers
+    }
     if (bn.ltn(253)) {
       const n = bn.toNumber()
       // No need for bitwise operation as the value is within a byte's range
@@ -708,7 +714,16 @@ export class Reader {
     return bn
   }
 
-  public readVarIntNum (): number {
+  public readInt64LEBn (): BigNumber {
+    const bin = this.readReverse(8)
+    let bn = new BigNumber(bin)
+    if (bn.gte(OverflowInt64)) {
+      bn = bn.sub(OverflowUint64) // Adjust for negative numbers
+    }
+    return bn
+  }
+
+  public readVarIntNum (signed: boolean = true): number {
     const first = this.readUInt8()
     let bn: BigNumber
     switch (first) {
@@ -717,7 +732,7 @@ export class Reader {
       case 0xfe:
         return this.readUInt32LE()
       case 0xff:
-        bn = this.readUInt64LEBn()
+        bn = signed ? this.readInt64LEBn() : this.readUInt64LEBn()
         if (bn.lte(new BigNumber(2).pow(new BigNumber(53)))) {
           return bn.toNumber()
         } else {
@@ -801,3 +816,6 @@ export const minimallyEncode = (buf: number[]): number[] => {
   // If we found the whole thing is zeros, then we have a zero.
   return []
 }
+
+const OverflowInt64 = new BigNumber(2).pow(new BigNumber(63))
+const OverflowUint64 = new BigNumber(2).pow(new BigNumber(64))