@bsv/wallet-toolbox 1.7.14 → 1.7.16

package/mobile/node_modules/@bsv/sdk/src/compat/Utxo.ts

@@ -0,0 +1,59 @@
+import Transaction from '../transaction/Transaction.js'
+import TransactionInput from '../transaction/TransactionInput.js'
+import LockingScript from '../script/LockingScript.js'
+import UnlockingScript from '../script/UnlockingScript.js'
+
+interface jsonUtxo {
+  txid: string
+  vout: number
+  satoshis: number
+  script: string
+}
+/**
+ * @method fromUtxo
+ *
+ * @description
+ * This function creates a transaction input from a utxo json object
+ * The idea being old code that uses utxos rather than sourceTranactions can convert using this.
+ *
+ * @deprecated
+ * This approach is made available for compatibility only. It is deprecated in favor of using sourceTransactions
+ * directly. It's recommended that wallets general keep transactions which store unspent outputs in their entirety,
+ * along with corresonding Merkle paths. The reason you would keep the whole transaction is such that you can prove
+ * the txid, and therefore its inclusion within a specific block.
+ *
+ * @example
+ * const i = fromUtxo({
+ *   txid: '434555433eaca96dff6e71a4d02febd0dd3832e5ca4e5734623ca914522e17d5',
+ *   vout: 0,
+ *   script: '51',
+ *   satoshis: 1234
+ * }, new P2PKH().unlock(p))
+ *
+ * tx.addInput(i)
+ *
+ * @param utxo: jsonUtxo
+ * @param unlockingScriptTemplate: { sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>, estimateLength: (tx: Transaction, inputIndex: number) => Promise<number> }
+ * @returns
+ */
+export default function fromUtxo (
+  utxo: jsonUtxo,
+  unlockingScriptTemplate: {
+    sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>
+    estimateLength: (tx: Transaction, inputIndex: number) => Promise<number>
+  }
+): TransactionInput {
+  const sourceTransaction = new Transaction(0, [], [], 0)
+  sourceTransaction.outputs = Array(utxo.vout + 1).fill(null)
+  sourceTransaction.outputs[utxo.vout] = {
+    satoshis: utxo.satoshis,
+    lockingScript: LockingScript.fromHex(utxo.script)
+  }
+  return {
+    sourceTransaction,
+    sourceTXID: utxo.txid,
+    sourceOutputIndex: utxo.vout,
+    unlockingScriptTemplate,
+    sequence: 0xffffffff
+  }
+}

package/mobile/node_modules/@bsv/sdk/src/compat/__tests/BSM.test.ts

@@ -0,0 +1,80 @@
+import { sign, verify, magicHash } from '../BSM'
+import { toArray } from '../../primitives/utils'
+import PrivateKey from '../../primitives/PrivateKey'
+import PublicKey from '../../primitives/PublicKey'
+import Signature from '../../primitives/Signature'
+import BigNumber from '../../primitives/BigNumber'
+
+describe('BSM', () => {
+  describe('magicHash', () => {
+    it('should return a hash', () => {
+      const buf = toArray('001122', 'hex')
+      const hashBuf = magicHash(buf)
+      expect(hashBuf.length).toEqual(32)
+    })
+  })
+  describe('sign', () => {
+    const messageBuf = toArray('this is my message', 'utf8')
+    const privateKey = new PrivateKey(42)
+
+    it('should return a signature', () => {
+      const sig = sign(messageBuf, privateKey, 'raw')
+
+      if (sig instanceof Signature) { // ✅ Explicitly check if `sig` is a Signature instance
+        const derSignature = sig.toDER()
+        expect(derSignature.length).toEqual(70)
+      } else {
+        throw new Error('Expected a Signature object, but got a different type')
+      }
+    })
+
+    it('Creates the correct base64 signature', () => {
+      const privateKey = PrivateKey.fromWif(
+        'L211enC224G1kV8pyyq7bjVd9SxZebnRYEzzM3i7ZHCc1c5E7dQu'
+      )
+      const sig = sign(toArray('hello world', 'utf8'), privateKey, 'base64')
+      expect(sig).toEqual(
+        'H4T8Asr0WkC6wYfBESR6pCAfECtdsPM4fwiSQ2qndFi8dVtv/mrOFaySx9xQE7j24ugoJ4iGnsRwAC8QwaoHOXk='
+      )
+    })
+  })
+  describe('verify', () => {
+    const messageBuf = toArray('this is my message', 'utf8')
+    const privateKey = new PrivateKey(42)
+
+    it('should verify a signed message', () => {
+      const sig = sign(messageBuf, privateKey, 'raw')
+      if (typeof sig !== 'string') {
+        expect(verify(messageBuf, sig, privateKey.toPublicKey())).toEqual(true)
+      } else {
+        throw new Error('Expected a Signature object, but got a string')
+      }
+    })
+    it('Should verify a signed message in base64', () => {
+      const message = toArray('Texas', 'utf8')
+      const signature = Signature.fromCompact(
+        'IAV89EkfHSzAIA8cEWbbKHUYzJqcShkpWaXGJ5+mf4+YIlf3XNlr0bj9X60sNe1A7+x9qyk+zmXropMDY4370n8=',
+        'base64'
+      )
+      const publicKey = PublicKey.fromString(
+        '03d4d1a6c5d8c03b0e671bc1891b69afaecb40c0686188fe9019f93581b43e8334'
+      )
+      expect(verify(message, signature, publicKey)).toBe(true)
+    })
+    it('Should be able to calculate the recovery number for a signature and public key', () => {
+      const message = toArray('Texas', 'utf8')
+      const signature = Signature.fromCompact(
+        'IAV89EkfHSzAIA8cEWbbKHUYzJqcShkpWaXGJ5+mf4+YIlf3XNlr0bj9X60sNe1A7+x9qyk+zmXropMDY4370n8=',
+        'base64'
+      )
+      const publicKey = PublicKey.fromString(
+        '03d4d1a6c5d8c03b0e671bc1891b69afaecb40c0686188fe9019f93581b43e8334'
+      )
+      const msgHash = new BigNumber(magicHash(message))
+      const recovery = signature.CalculateRecoveryFactor(publicKey, msgHash)
+      expect(recovery).toBe(1)
+      const recoveredPubkey = signature.RecoverPublicKey(recovery, msgHash)
+      expect(recoveredPubkey.toDER()).toEqual(publicKey.toDER())
+    })
+  })
+})

package/mobile/node_modules/@bsv/sdk/src/compat/__tests/ECIES.test.ts

@@ -0,0 +1,184 @@
+import ECIES from '../ECIES'
+import * as Hash from '../../primitives/Hash'
+import PrivateKey from '../../primitives/PrivateKey'
+import { Utils } from '../../primitives/index'
+
+describe('#ECIES', () => {
+  it('should make a new ECIES object', () => {
+    expect(ECIES).toBeDefined()
+  })
+
+  const fromkey = new PrivateKey(42)
+  const tokey = new PrivateKey(88)
+  const messageBuf = Hash.sha256(
+    Utils.toArray('my message is the hash of this string', 'utf8')
+  )
+
+  describe('@bitcoreEncrypt', () => {
+    it('should return a buffer', () => {
+      const encBuf = ECIES.bitcoreEncrypt(
+        messageBuf,
+        tokey.toPublicKey(),
+        fromkey
+      )
+      expect(Array.isArray(encBuf)).toEqual(true)
+    })
+
+    it('should return a buffer if fromkey is not present', () => {
+      const encBuf = ECIES.bitcoreEncrypt(messageBuf, tokey.toPublicKey())
+      expect(Array.isArray(encBuf)).toEqual(true)
+    })
+  })
+
+  describe('@bitcoreDecrypt', () => {
+    it('should decrypt that which was encrypted', () => {
+      const encBuf = ECIES.bitcoreEncrypt(
+        messageBuf,
+        tokey.toPublicKey(),
+        fromkey
+      )
+      const messageBuf2 = ECIES.bitcoreDecrypt(encBuf, tokey)
+      expect(Utils.toHex(messageBuf2)).toEqual(Utils.toHex(messageBuf))
+    })
+
+    it('should decrypt that which was encrypted if fromPrivateKey was randomly generated', () => {
+      const encBuf = ECIES.bitcoreEncrypt(messageBuf, tokey.toPublicKey())
+      const messageBuf2 = ECIES.bitcoreDecrypt(encBuf, tokey)
+      expect(messageBuf2).toEqual(messageBuf)
+    })
+  })
+
+  describe('Electrum ECIES', () => {
+    // const alicePrivateKey = PrivateKey.fromString('L1Ejc5dAigm5XrM3mNptMEsNnHzS7s51YxU7J61ewGshZTKkbmzJ')
+    // const bobPrivateKey = PrivateKey.fromString('KxfxrUXSMjJQcb3JgnaaA6MqsrKQ1nBSxvhuigdKRyFiEm6BZDgG')
+    const alicePrivateKey = PrivateKey.fromString(
+      '77e06abc52bf065cb5164c5deca839d0276911991a2730be4d8d0a0307de7ceb',
+      16
+    )
+    const bobPrivateKey = PrivateKey.fromString(
+      '2b57c7c5e408ce927eef5e2efb49cfdadde77961d342daa72284bb3d6590862d',
+      16
+    )
+
+    it('should do these test vectors correctly', () => {
+      const message = Utils.toArray('this is my test message', 'utf8')
+
+      expect(
+        ECIES.electrumDecrypt(
+          Utils.toArray(
+            'QklFMQOGFyMXLo9Qv047K3BYJhmnJgt58EC8skYP/R2QU/U0yXXHOt6L3tKmrXho6yj6phfoiMkBOhUldRPnEI4fSZXbiaH4FsxKIOOvzolIFVAS0FplUmib2HnlAM1yP/iiPsU=',
+            'base64'
+          ),
+          alicePrivateKey
+        )
+      ).toEqual(message)
+      expect(
+        ECIES.electrumDecrypt(
+          Utils.toArray(
+            'QklFMQM55QTWSSsILaluEejwOXlrBs1IVcEB4kkqbxDz4Fap53XHOt6L3tKmrXho6yj6phfoiMkBOhUldRPnEI4fSZXbvZJHgyAzxA6SoujduvJXv+A9ri3po9veilrmc8p6dwo=',
+            'base64'
+          ),
+          bobPrivateKey
+        )
+      ).toEqual(message)
+
+      expect(
+        Utils.toBase64(
+          ECIES.electrumEncrypt(
+            message,
+            bobPrivateKey.toPublicKey(),
+            alicePrivateKey
+          )
+        )
+      ).toEqual(
+        'QklFMQM55QTWSSsILaluEejwOXlrBs1IVcEB4kkqbxDz4Fap53XHOt6L3tKmrXho6yj6phfoiMkBOhUldRPnEI4fSZXbvZJHgyAzxA6SoujduvJXv+A9ri3po9veilrmc8p6dwo='
+      )
+      expect(
+        Utils.toBase64(
+          ECIES.electrumEncrypt(
+            message,
+            alicePrivateKey.toPublicKey(),
+            bobPrivateKey
+          )
+        )
+      ).toEqual(
+        'QklFMQOGFyMXLo9Qv047K3BYJhmnJgt58EC8skYP/R2QU/U0yXXHOt6L3tKmrXho6yj6phfoiMkBOhUldRPnEI4fSZXbiaH4FsxKIOOvzolIFVAS0FplUmib2HnlAM1yP/iiPsU='
+      )
+    })
+
+    it('should encrypt and decrypt symmetrically with matching strings in ECDH noKey mode', () => {
+      const message = Utils.toArray('this is my ECDH test message', 'utf8')
+      const ecdhMessageEncryptedBob = ECIES.electrumEncrypt(
+        message,
+        bobPrivateKey.toPublicKey(),
+        alicePrivateKey,
+        true
+      )
+      const ecdhMessageEncryptedAlice = ECIES.electrumEncrypt(
+        message,
+        alicePrivateKey.toPublicKey(),
+        bobPrivateKey,
+        true
+      )
+      expect(ecdhMessageEncryptedBob).toEqual(ecdhMessageEncryptedAlice)
+      expect(
+        ECIES.electrumDecrypt(
+          ecdhMessageEncryptedAlice,
+          bobPrivateKey,
+          alicePrivateKey.toPublicKey()
+        )
+      ).toEqual(Utils.toArray('this is my ECDH test message', 'utf8'))
+      expect(
+        ECIES.electrumDecrypt(
+          ecdhMessageEncryptedBob,
+          alicePrivateKey,
+          bobPrivateKey.toPublicKey()
+        )
+      ).toEqual(Utils.toArray('this is my ECDH test message', 'utf8'))
+    })
+
+    it('should encrypt and decrypt using ephemeral fromPrivateKey', () => {
+      const message = Utils.toArray(
+        'this is my ephemeral key test message',
+        'utf8'
+      )
+      const encryptedMessage = ECIES.electrumEncrypt(
+        message,
+        bobPrivateKey.toPublicKey()
+      )
+      expect(ECIES.electrumDecrypt(encryptedMessage, bobPrivateKey)).toEqual(
+        message
+      )
+    })
+
+    it('should encrypt and decrypt message with counterparty public key', () => {
+      const wif = 'L211enC224G1kV8pyyq7bjVd9SxZebnRYEzzM3i7ZHCc1c5E7dQu'
+      const senderPrivateKey = PrivateKey.fromWif(wif)
+      const senderPublicKey = senderPrivateKey.toPublicKey()
+      const msgStr = 'hello world'
+      const messageBuf = Utils.toArray(msgStr, 'utf8')
+
+      // Create a random counterparty (recipient) public/private key pair
+      const recipientPrivateKey = PrivateKey.fromRandom()
+      const recipientPublicKey = recipientPrivateKey.toPublicKey()
+
+      // Encrypt the message using electrumEncrypt
+      const encryptedMessage = ECIES.electrumEncrypt(
+        messageBuf,
+        recipientPublicKey,
+        senderPrivateKey
+      )
+
+      // Decrypt the message using electrumDecrypt
+      const decryptedMessageBuf = ECIES.electrumDecrypt(
+        encryptedMessage,
+        recipientPrivateKey,
+        senderPublicKey
+      )
+
+      const decryptedMsgStr = Utils.toUTF8(decryptedMessageBuf)
+
+      expect(decryptedMsgStr).toEqual(msgStr)
+    })
+  })
+})