@bsv/sdk 1.3.12 → 1.3.13

package/src/script/templates/RPuzzle.ts

@@ -1,13 +1,13 @@
-import OP from '../OP.js'
-import ScriptTemplate from '../ScriptTemplate.js'
-import LockingScript from '../LockingScript.js'
-import UnlockingScript from '../UnlockingScript.js'
-import Transaction from '../../transaction/Transaction.js'
-import PrivateKey from '../../primitives/PrivateKey.js'
-import TransactionSignature from '../../primitives/TransactionSignature.js'
-import { sha256 } from '../../primitives/Hash.js'
-import ScriptChunk from '../ScriptChunk.js'
-import BigNumber from '../../primitives/BigNumber.js'
+import OP from "../OP";
+import ScriptTemplate from "../ScriptTemplate";
+import LockingScript from "../LockingScript";
+import UnlockingScript from "../UnlockingScript";
+import Transaction from "../../transaction/Transaction";
+import PrivateKey from "../../primitives/PrivateKey";
+import TransactionSignature from "../../primitives/TransactionSignature";
+import { sha256 } from "../../primitives/Hash";
+import ScriptChunk from "../ScriptChunk";
+import BigNumber from "../../primitives/BigNumber";
 
 /**
  * RPuzzle class implementing ScriptTemplate.
@@ -15,7 +15,7 @@ import BigNumber from '../../primitives/BigNumber.js'
  * This class provides methods to create R Puzzle and R Puzzle Hash locking and unlocking scripts, including the unlocking of UTXOs with the correct K value.
  */
 export default class RPuzzle implements ScriptTemplate {
-  type: 'raw' | 'SHA1' | 'SHA256' | 'HASH256' | 'RIPEMD160' | 'HASH160' = 'raw'
+  type: "raw" | "SHA1" | "SHA256" | "HASH256" | "RIPEMD160" | "HASH160" = "raw";
 
   /**
    * @constructor
@@ -23,8 +23,16 @@ export default class RPuzzle implements ScriptTemplate {
    *
    * @param {'raw'|'SHA1'|'SHA256'|'HASH256'|'RIPEMD160'|'HASH160'} type Denotes the type of puzzle to create
    */
-  constructor(type: 'raw' | 'SHA1' | 'SHA256' | 'HASH256' | 'RIPEMD160' | 'HASH160' = 'raw') {
-    this.type = type
+  constructor(
+    type:
+      | "raw"
+      | "SHA1"
+      | "SHA256"
+      | "HASH256"
+      | "RIPEMD160"
+      | "HASH160" = "raw"
+  ) {
+    this.type = type;
   }
 
   /**
@@ -43,17 +51,17 @@ export default class RPuzzle implements ScriptTemplate {
       { op: OP.OP_SPLIT },
       { op: OP.OP_SWAP },
       { op: OP.OP_SPLIT },
-      { op: OP.OP_DROP }
-    ]
-    if (this.type !== 'raw') {
+      { op: OP.OP_DROP },
+    ];
+    if (this.type !== "raw") {
       chunks.push({
-        op: OP['OP_' + this.type]
-      })
+        op: OP["OP_" + this.type],
+      });
     }
-    chunks.push({ op: value.length, data: value })
-    chunks.push({ op: OP.OP_EQUALVERIFY })
-    chunks.push({ op: OP.OP_CHECKSIG })
-    return new LockingScript(chunks)
+    chunks.push({ op: value.length, data: value });
+    chunks.push({ op: OP.OP_EQUALVERIFY });
+    chunks.push({ op: OP.OP_CHECKSIG });
+    return new LockingScript(chunks);
   }
 
   /**
@@ -73,68 +81,78 @@ export default class RPuzzle implements ScriptTemplate {
   unlock(
     k: BigNumber,
     privateKey: PrivateKey,
-    signOutputs: 'all' | 'none' | 'single' = 'all',
+    signOutputs: "all" | "none" | "single" = "all",
     anyoneCanPay: boolean = false
   ): {
-    sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>
-    estimateLength: () => Promise<108>
+    sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>;
+    estimateLength: () => Promise<108>;
   } {
     return {
       sign: async (tx: Transaction, inputIndex: number) => {
-        if (typeof privateKey === 'undefined') {
-          privateKey = PrivateKey.fromRandom()
+        if (typeof privateKey === "undefined") {
+          privateKey = PrivateKey.fromRandom();
         }
-        let signatureScope = TransactionSignature.SIGHASH_FORKID
-        if (signOutputs === 'all') {
-          signatureScope |= TransactionSignature.SIGHASH_ALL
+        let signatureScope = TransactionSignature.SIGHASH_FORKID;
+        if (signOutputs === "all") {
+          signatureScope |= TransactionSignature.SIGHASH_ALL;
         }
-        if (signOutputs === 'none') {
-          signatureScope |= TransactionSignature.SIGHASH_NONE
+        if (signOutputs === "none") {
+          signatureScope |= TransactionSignature.SIGHASH_NONE;
         }
-        if (signOutputs === 'single') {
-          signatureScope |= TransactionSignature.SIGHASH_SINGLE
+        if (signOutputs === "single") {
+          signatureScope |= TransactionSignature.SIGHASH_SINGLE;
         }
         if (anyoneCanPay) {
-          signatureScope |= TransactionSignature.SIGHASH_ANYONECANPAY
+          signatureScope |= TransactionSignature.SIGHASH_ANYONECANPAY;
         }
-        const otherInputs = [...tx.inputs]
-        const [input] = otherInputs.splice(inputIndex, 1)
-        if (typeof input.sourceTransaction !== 'object') {
+        const otherInputs = [...tx.inputs];
+        const [input] = otherInputs.splice(inputIndex, 1);
+        if (typeof input.sourceTransaction !== "object") {
           throw new Error(
-            'The source transaction is needed for transaction signing.'
-          )
+            "The source transaction is needed for transaction signing."
+          );
         }
         const preimage = TransactionSignature.format({
-          sourceTXID: input.sourceTransaction.id('hex'),
+          sourceTXID: input.sourceTransaction.id("hex"),
           sourceOutputIndex: input.sourceOutputIndex,
-          sourceSatoshis: input.sourceTransaction.outputs[input.sourceOutputIndex].satoshis,
+          sourceSatoshis:
+            input.sourceTransaction.outputs[input.sourceOutputIndex].satoshis,
           transactionVersion: tx.version,
           otherInputs,
           inputIndex,
           outputs: tx.outputs,
           inputSequence: input.sequence,
-          subscript: input.sourceTransaction.outputs[input.sourceOutputIndex].lockingScript,
+          subscript:
+            input.sourceTransaction.outputs[input.sourceOutputIndex]
+              .lockingScript,
           lockTime: tx.lockTime,
-          scope: signatureScope
-        })
-        const rawSignature = privateKey.sign(sha256(preimage), undefined, true, k)
+          scope: signatureScope,
+        });
+        const rawSignature = privateKey.sign(
+          sha256(preimage),
+          undefined,
+          true,
+          k
+        );
         const sig = new TransactionSignature(
           rawSignature.r,
           rawSignature.s,
           signatureScope
-        )
-        const sigForScript = sig.toChecksigFormat()
-        const pubkeyForScript = privateKey.toPublicKey().encode(true) as number[]
+        );
+        const sigForScript = sig.toChecksigFormat();
+        const pubkeyForScript = privateKey
+          .toPublicKey()
+          .encode(true) as number[];
         return new UnlockingScript([
           { op: sigForScript.length, data: sigForScript },
-          { op: pubkeyForScript.length, data: pubkeyForScript }
-        ])
+          { op: pubkeyForScript.length, data: pubkeyForScript },
+        ]);
       },
       estimateLength: async () => {
         // public key (1+33) + signature (1+73)
         // Note: We add 1 to each element's length because of the associated OP_PUSH
-        return 108
-      }
-    }
+        return 108;
+      },
+    };
   }
 }

package/src/script/templates/__tests/PushDrop.test.ts

@@ -1,33 +1,67 @@
 /* eslint-env jest */
-import PushDrop from '../../../../dist/cjs/src/script/templates/PushDrop.js'
-import ProtoWallet from '../../../../dist/cjs/src/wallet/ProtoWallet.js'
-import { PrivateKey, Utils } from '../../../../dist/cjs/src/primitives/index.js'
-import { Script, Spend } from '../../../../dist/cjs/src/script/index.js'
-import { Transaction } from '../../../../dist/cjs/src/transaction/index.js'
+import PushDrop from '../../../script/templates/PushDrop'
+import { CompletedProtoWallet } from '../../../auth/certificates/__tests/CompletedProtoWallet'
+import { PrivateKey, Utils } from '../../../primitives/index'
+import { Script, Spend } from '../../../script/index'
+import { Transaction } from '../../../transaction/index'
 
 describe('PushDrop', () => {
   let privateKey: typeof PrivateKey
   let wallet
   let pushDrop: PushDrop
 
-  const createDecodeRedeem = async (fields: number[][] = [], protocolID: [0 | 1 | 2, string] = [0, 'tests'], keyID: string = 'test-key', counterparty: string = 'self', signOutputs: 'all' | 'none' | 'single' = 'all', anyoneCanPay: boolean = false) => {
-    const lockingScript = await pushDrop.lock(fields, protocolID, keyID, counterparty)
+  const createDecodeRedeem = async (
+    fields: number[][] = [],
+    protocolID: [0 | 1 | 2, string] = [0, 'tests'],
+    keyID: string = 'test-key',
+    counterparty: string = 'self',
+    signOutputs: 'all' | 'none' | 'single' = 'all',
+    anyoneCanPay: boolean = false
+  ) => {
+    const lockingScript = await pushDrop.lock(
+      fields,
+      protocolID,
+      keyID,
+      counterparty
+    )
     expect(lockingScript).toBeInstanceOf(Script)
     const decoded = await PushDrop.decode(lockingScript)
     expect(decoded.fields).toEqual(fields)
-    const expectedPublicKey = (await wallet.getPublicKey({ protocolID, keyID, counterparty })).publicKey
+    const expectedPublicKey = (
+      await wallet.getPublicKey({ protocolID, keyID, counterparty })
+    ).publicKey
     expect(decoded.lockingPublicKey.toString()).toEqual(expectedPublicKey)
     const satoshis = 1
-    const unlockingTemplate = await pushDrop.unlock(protocolID, keyID, counterparty, signOutputs, anyoneCanPay)
-    const sourceTx = new Transaction(1, [], [{
-      lockingScript,
-      satoshis
-    }], 0)
-    const spendTx = new Transaction(1, [{
-      sourceTransaction: sourceTx,
-      sourceOutputIndex: 0,
-      sequence: 0xffffffff
-    }], [], 0)
+    const unlockingTemplate = await pushDrop.unlock(
+      protocolID,
+      keyID,
+      counterparty,
+      signOutputs,
+      anyoneCanPay
+    )
+    const sourceTx = new Transaction(
+      1,
+      [],
+      [
+        {
+          lockingScript,
+          satoshis
+        }
+      ],
+      0
+    )
+    const spendTx = new Transaction(
+      1,
+      [
+        {
+          sourceTransaction: sourceTx,
+          sourceOutputIndex: 0,
+          sequence: 0xffffffff
+        }
+      ],
+      [],
+      0
+    )
     const unlockingScript = await unlockingTemplate.sign(spendTx, 0)
     expect(await unlockingTemplate.estimateLength()).toEqual(73)
     const spend = new Spend({
@@ -48,8 +82,8 @@ describe('PushDrop', () => {
   }
 
   beforeEach(() => {
-    privateKey = PrivateKey.fromRandom()
-    wallet = new ProtoWallet(privateKey)
+    let privateKey = PrivateKey.fromRandom()
+    wallet = new CompletedProtoWallet(privateKey)
     pushDrop = new PushDrop(wallet)
   })
 
@@ -64,11 +98,46 @@ describe('PushDrop', () => {
     await createDecodeRedeem([new Array(70000).fill(0xff)])
     await createDecodeRedeem([[0], [1], [2]])
     await createDecodeRedeem([[0], [1], [2], [3]])
-    await createDecodeRedeem([[3, 1, 4, 1, 5, 9]], undefined, undefined, undefined, 'none', false)
-    await createDecodeRedeem([[3, 1, 4, 1, 5, 9]], undefined, undefined, undefined, 'single', false)
-    await createDecodeRedeem([[3, 1, 4, 1, 5, 9]], undefined, undefined, undefined, 'all', true)
-    await createDecodeRedeem([[3, 1, 4, 1, 5, 9]], undefined, undefined, undefined, 'none', true)
-    await createDecodeRedeem([[3, 1, 4, 1, 5, 9]], undefined, undefined, undefined, 'single', true)
+    await createDecodeRedeem(
+      [[3, 1, 4, 1, 5, 9]],
+      undefined,
+      undefined,
+      undefined,
+      'none',
+      false
+    )
+    await createDecodeRedeem(
+      [[3, 1, 4, 1, 5, 9]],
+      undefined,
+      undefined,
+      undefined,
+      'single',
+      false
+    )
+    await createDecodeRedeem(
+      [[3, 1, 4, 1, 5, 9]],
+      undefined,
+      undefined,
+      undefined,
+      'all',
+      true
+    )
+    await createDecodeRedeem(
+      [[3, 1, 4, 1, 5, 9]],
+      undefined,
+      undefined,
+      undefined,
+      'none',
+      true
+    )
+    await createDecodeRedeem(
+      [[3, 1, 4, 1, 5, 9]],
+      undefined,
+      undefined,
+      undefined,
+      'single',
+      true
+    )
   })
 
   describe('lock', () => {
@@ -81,7 +150,12 @@ describe('PushDrop', () => {
       const protocolID: [0 | 1 | 2, string] = [0, 'tests']
       const keyID = 'test-key'
       const counterparty = 'self'
-      const lockingScript = await pushDrop.lock(fields, protocolID, keyID, counterparty)
+      const lockingScript = await pushDrop.lock(
+        fields,
+        protocolID,
+        keyID,
+        counterparty
+      )
 
       // Check that the locking script is not null
       expect(lockingScript).toBeInstanceOf(Script)
@@ -89,7 +163,9 @@ describe('PushDrop', () => {
       // Decode the locking script and check the fields and locking public key
       const decoded = await PushDrop.decode(lockingScript)
       expect(decoded.fields).toEqual(fields)
-      const expectedPublicKey = (await wallet.getPublicKey({ protocolID, keyID, counterparty })).publicKey
+      const expectedPublicKey = (
+        await wallet.getPublicKey({ protocolID, keyID, counterparty })
+      ).publicKey
       expect(decoded.lockingPublicKey.toString()).toEqual(expectedPublicKey)
     })
   })
@@ -104,18 +180,41 @@ describe('PushDrop', () => {
       const protocolID: [0 | 1 | 2, string] = [0, 'tests']
       const keyID = 'test-key'
       const counterparty = 'self'
-      const lockingScript = await pushDrop.lock(fields, protocolID, keyID, counterparty)
+      const lockingScript = await pushDrop.lock(
+        fields,
+        protocolID,
+        keyID,
+        counterparty
+      )
       const satoshis = 1
-      const unlockingTemplate = await pushDrop.unlock(protocolID, keyID, counterparty)
-      const sourceTx = new Transaction(1, [], [{
-        lockingScript,
-        satoshis
-      }], 0)
-      const spendTx = new Transaction(1, [{
-        sourceTransaction: sourceTx,
-        sourceOutputIndex: 0,
-        sequence: 0xffffffff
-      }], [], 0)
+      const unlockingTemplate = await pushDrop.unlock(
+        protocolID,
+        keyID,
+        counterparty
+      )
+      const sourceTx = new Transaction(
+        1,
+        [],
+        [
+          {
+            lockingScript,
+            satoshis
+          }
+        ],
+        0
+      )
+      const spendTx = new Transaction(
+        1,
+        [
+          {
+            sourceTransaction: sourceTx,
+            sourceOutputIndex: 0,
+            sequence: 0xffffffff
+          }
+        ],
+        [],
+        0
+      )
       const unlockingScript = await unlockingTemplate.sign(spendTx, 0)
       expect(await unlockingTemplate.estimateLength()).toEqual(73)
       const spend = new Spend({
@@ -147,11 +246,18 @@ describe('PushDrop', () => {
       const keyID = 'test-key'
       const counterparty = 'self'
 
-      const lockingScript = await pushDrop.lock(fields, protocolID, keyID, counterparty)
+      const lockingScript = await pushDrop.lock(
+        fields,
+        protocolID,
+        keyID,
+        counterparty
+      )
 
       const decoded = await PushDrop.decode(lockingScript)
       expect(decoded.fields).toEqual(fields)
-      const expectedPublicKey = (await wallet.getPublicKey({ protocolID, keyID, counterparty })).publicKey
+      const expectedPublicKey = (
+        await wallet.getPublicKey({ protocolID, keyID, counterparty })
+      ).publicKey
       expect(decoded.lockingPublicKey.toString()).toEqual(expectedPublicKey)
     })
   })

package/src/script/templates/index.ts

@@ -1,3 +1,3 @@
-export { default as P2PKH } from './P2PKH.js'
-export { default as RPuzzle } from './RPuzzle.js'
-export { default as PushDrop } from './PushDrop.js'
+export { default as P2PKH } from "./P2PKH";
+export { default as RPuzzle } from "./RPuzzle";
+export { default as PushDrop } from "./PushDrop";

package/src/totp/__tests/totp.test.ts

@@ -1,80 +1,80 @@
-import { toArray } from "../../../dist/cjs/src/primitives/utils.js";
-import { TOTP } from "../../../dist/cjs/src/totp/totp.js";
+import { toArray } from '../../primitives/utils'
+import { TOTP } from '../../totp/totp'
 
-const secret = toArray("48656c6c6f21deadbeef", 'hex');
-const period = 30; //sec
-const periodMS = 30 * 1000; //ms
+const secret = toArray('48656c6c6f21deadbeef', 'hex')
+const period = 30 //sec
+const periodMS = 30 * 1000 //ms
 const options = {
   digits: 6,
   period,
-  algorithm: "SHA-1",
-};
+  algorithm: 'SHA-1' as 'SHA-1'
+}
 
-describe("totp generation and validation", () => {
-  beforeEach(() => jest.useFakeTimers());
-  afterEach(() => jest.resetAllMocks());
+describe('totp generation and validation', () => {
+  beforeEach(() => jest.useFakeTimers())
+  afterEach(() => jest.resetAllMocks())
 
   test.each([
     {
       time: 0,
-      expected: "282760",
-      description: "should generate token at Unix epoch start",
+      expected: '282760',
+      description: 'should generate token at Unix epoch start'
     },
     {
       time: 1465324707000,
-      expected: "341128",
-      description: "should generate token for a specific timestamp in 2016",
+      expected: '341128',
+      description: 'should generate token for a specific timestamp in 2016'
     },
     {
       time: 1665644340000 + 1,
-      expected: "886842",
-      description: "should generate correct token at the start of the cycle",
+      expected: '886842',
+      description: 'should generate correct token at the start of the cycle'
     },
     {
       time: 1665644340000 - 1,
-      expected: "134996",
-      description: "should generate correct token at the end of the cycle",
+      expected: '134996',
+      description: 'should generate correct token at the end of the cycle'
     },
     {
       time: 1365324707000,
-      expected: "089029",
-      description: "should generate token with a leading zero",
-    },
-  ])("$description", async ({ time, expected }) => {
-    jest.setSystemTime(time);
+      expected: '089029',
+      description: 'should generate token with a leading zero'
+    }
+  ])('$description', async ({ time, expected }) => {
+    jest.setSystemTime(time)
 
     //check if expected passcode is generated
-    const passcode = TOTP.generate(secret, options);
-    expect(passcode).toEqual(expected);
+    const passcode = TOTP.generate(secret, options)
+    expect(passcode).toEqual(expected)
 
-    expect(TOTP.validate(secret, "000000", options)).toEqual(false); //this passcode should not be valid for any of above test cases
+    expect(TOTP.validate(secret, '000000', options)).toEqual(false) //this passcode should not be valid for any of above test cases
 
     //should not be valid for only a part of passcode
-    expect(TOTP.validate(secret, passcode.slice(1), options)).toEqual(false);
+    expect(TOTP.validate(secret, passcode.slice(1), options)).toEqual(false)
 
-    expect(TOTP.validate(secret, passcode, options)).toEqual(true);
+    expect(TOTP.validate(secret, passcode, options)).toEqual(true)
 
     const checkAdjacentWindow = (
       timeOfGeneration: number,
       expected: boolean
     ) => {
-      jest.setSystemTime(timeOfGeneration);
-      const adjacentTimewindowPasscode = TOTP.generate(secret, options);
+      jest.setSystemTime(timeOfGeneration)
+      const adjacentTimewindowPasscode = TOTP.generate(secret, options)
 
-      jest.setSystemTime(time);
+      jest.setSystemTime(time)
       expect(
         TOTP.validate(secret, adjacentTimewindowPasscode, options)
-      ).toEqual(expected);
-    };
+      ).toEqual(expected)
+    }
 
     //because the 'skew' is '1' by default, the passcode for the next window also should be valid
-    checkAdjacentWindow(time + periodMS, true);
-    checkAdjacentWindow(time - periodMS, true);
+    checkAdjacentWindow(time + periodMS, true)
+    checkAdjacentWindow(time - periodMS, true)
 
     //for 'skew': 1, other passcodes for further timewindows should not be valid
     for (let i = 2; i < 10; i++) {
-      checkAdjacentWindow(time + i * periodMS, false);
-      checkAdjacentWindow(time - i * periodMS, false);
+      checkAdjacentWindow(time + i * periodMS, false)
+      checkAdjacentWindow(time - i * periodMS, false)
     }
-  });
-});
+  })
+})

package/src/totp/index.ts

@@ -1 +1 @@
-export * from './totp.js'
+export * from './totp'

package/src/totp/totp.ts

@@ -1,5 +1,5 @@
-import { SHA1HMAC, SHA256HMAC, SHA512HMAC } from '../primitives/Hash.js'
-import BigNumber from '../primitives/BigNumber.js'
+import { SHA1HMAC, SHA256HMAC, SHA512HMAC } from '../primitives/Hash'
+import BigNumber from '../primitives/BigNumber'
 
 export type TOTPAlgorithm = 'SHA-1' | 'SHA-256' | 'SHA-512'