@bsv/sdk 1.3.11 → 1.3.13

package/src/script/index.ts

@@ -1,7 +1,7 @@
-export { default as OP } from './OP.js'
-export { default as Script } from './Script.js'
-export { default as LockingScript } from './LockingScript.js'
-export { default as UnlockingScript } from './UnlockingScript.js'
-export { default as Spend } from './Spend.js'
-export type { default as ScriptTemplate } from './ScriptTemplate.js'
-export * from './templates/index.js'
+export { default as OP } from './OP'
+export { default as Script } from './Script'
+export { default as LockingScript } from './LockingScript'
+export { default as UnlockingScript } from './UnlockingScript'
+export { default as Spend } from './Spend'
+export type { default as ScriptTemplate } from './ScriptTemplate'
+export * from './templates/index'

package/src/script/templates/P2PKH.ts

@@ -1,13 +1,13 @@
-import OP from '../OP.js'
-import ScriptTemplate from '../ScriptTemplate.js'
-import { fromBase58Check } from '../../primitives/utils.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 Script from '../Script.js'
+import OP from "../OP";
+import ScriptTemplate from "../ScriptTemplate";
+import { fromBase58Check } from "../../primitives/utils";
+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 Script from "../Script";
 
 /**
  * P2PKH (Pay To Public Key Hash) class implementing ScriptTemplate.
@@ -22,22 +22,24 @@ export default class P2PKH implements ScriptTemplate {
    * @returns {LockingScript} - A P2PKH locking script.
    */
   lock(pubkeyhash: string | number[]): LockingScript {
-    let data: number[]
-    if (typeof pubkeyhash === 'string') {
-      const hash = fromBase58Check(pubkeyhash)
-      if (hash.prefix[0] !== 0x00 && hash.prefix[0] !== 0x6f) throw new Error('only P2PKH is supported')
-      data = hash.data as number[]
+    let data: number[];
+    if (typeof pubkeyhash === "string") {
+      const hash = fromBase58Check(pubkeyhash);
+      if (hash.prefix[0] !== 0x00 && hash.prefix[0] !== 0x6f)
+        throw new Error("only P2PKH is supported");
+      data = hash.data as number[];
     } else {
-      data = pubkeyhash
+      data = pubkeyhash;
     }
-    if (data.length !== 20) throw new Error('P2PKH hash length must be 20 bytes')
+    if (data.length !== 20)
+      throw new Error("P2PKH hash length must be 20 bytes");
     return new LockingScript([
       { op: OP.OP_DUP },
       { op: OP.OP_HASH160 },
       { op: data.length, data },
       { op: OP.OP_EQUALVERIFY },
-      { op: OP.OP_CHECKSIG }
-    ])
+      { op: OP.OP_CHECKSIG },
+    ]);
   }
 
   /**
@@ -57,51 +59,58 @@ export default class P2PKH implements ScriptTemplate {
    */
   unlock(
     privateKey: PrivateKey,
-    signOutputs: 'all' | 'none' | 'single' = 'all',
+    signOutputs: "all" | "none" | "single" = "all",
     anyoneCanPay: boolean = false,
     sourceSatoshis?: number,
     lockingScript?: Script
   ): {
-    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) => {
-        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 input = tx.inputs[inputIndex]
+        const input = tx.inputs[inputIndex];
 
-        const otherInputs = tx.inputs.filter((_, index) => index !== inputIndex)
+        const otherInputs = tx.inputs.filter(
+          (_, index) => index !== inputIndex
+        );
 
-        const sourceTXID = input.sourceTXID ? input.sourceTXID : input.sourceTransaction?.id('hex')
+        const sourceTXID = input.sourceTXID
+          ? input.sourceTXID
+          : input.sourceTransaction?.id("hex");
         if (!sourceTXID) {
           throw new Error(
-            'The input sourceTXID or sourceTransaction is required for transaction signing.'
-          )
+            "The input sourceTXID or sourceTransaction is required for transaction signing."
+          );
         }
-        sourceSatoshis ||= input.sourceTransaction?.outputs[input.sourceOutputIndex].satoshis
+        sourceSatoshis ||=
+          input.sourceTransaction?.outputs[input.sourceOutputIndex].satoshis;
         if (!sourceSatoshis) {
           throw new Error(
-            'The sourceSatoshis or input sourceTransaction is required for transaction signing.'
-          )
+            "The sourceSatoshis or input sourceTransaction is required for transaction signing."
+          );
         }
-        lockingScript ||= input.sourceTransaction?.outputs[input.sourceOutputIndex].lockingScript
+        lockingScript ||=
+          input.sourceTransaction?.outputs[input.sourceOutputIndex]
+            .lockingScript;
         if (!lockingScript) {
           throw new Error(
-            'The lockingScript or input sourceTransaction is required for transaction signing.'
-          )
+            "The lockingScript or input sourceTransaction is required for transaction signing."
+          );
         }
 
         const preimage = TransactionSignature.format({
@@ -115,26 +124,28 @@ export default class P2PKH implements ScriptTemplate {
           inputSequence: input.sequence,
           subscript: lockingScript,
           lockTime: tx.lockTime,
-          scope: signatureScope
-        })
-        const rawSignature = privateKey.sign(sha256(preimage))
+          scope: signatureScope,
+        });
+        const rawSignature = privateKey.sign(sha256(preimage));
         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/PushDrop.ts

@@ -1,8 +1,14 @@
-import { ScriptTemplate, LockingScript, UnlockingScript, OP } from '../index.js'
-import { Utils, Hash, TransactionSignature, Signature, PublicKey } from '../../primitives/index.js'
-import { WalletInterface } from '../../wallet/Wallet.interfaces.js'
-import { Transaction } from '../../transaction/index.js'
-import { SecurityLevel } from '../../wallet/Wallet.interfaces.js'
+import { ScriptTemplate, LockingScript, UnlockingScript, OP } from "../index";
+import {
+  Utils,
+  Hash,
+  TransactionSignature,
+  Signature,
+  PublicKey,
+} from "../../primitives/index";
+import { WalletInterface } from "../../wallet/Wallet.interfaces";
+import { Transaction } from "../../transaction/index";
+import { SecurityLevel } from "../../wallet/Wallet.interfaces";
 
 /**
  * For a given piece of data to push onto the stack in script, creates the correct minimally-encoded script chunk,
@@ -10,41 +16,43 @@ import { SecurityLevel } from '../../wallet/Wallet.interfaces.js'
  *
  * TODO: This should be made into a TS-SDK util (distinct from the `minimallyEncode` util)
  */
-const createMinimallyEncodedScriptChunk = (data: number[]): { op: number, data?: number[] } => {
+const createMinimallyEncodedScriptChunk = (
+  data: number[]
+): { op: number; data?: number[] } => {
   if (data.length === 0) {
     // Could have used OP_0.
-    return { op: 0 }
+    return { op: 0 };
   }
   if (data.length === 1 && data[0] === 0) {
     // Could have used OP_0.
-    return { op: 0 }
+    return { op: 0 };
   }
   if (data.length === 1 && data[0] > 0 && data[0] <= 16) {
     // Could have used OP_0 .. OP_16.
-    return { op: 0x50 + data[0] }
+    return { op: 0x50 + data[0] };
   }
   if (data.length === 1 && data[0] === 0x81) {
     // Could have used OP_1NEGATE.
-    return { op: 0x4f }
+    return { op: 0x4f };
   }
   if (data.length <= 75) {
     // Could have used a direct push (opcode indicating number of bytes
     // pushed + those bytes).
-    return { op: data.length, data }
+    return { op: data.length, data };
   }
   if (data.length <= 255) {
     // Could have used OP_PUSHDATA.
-    return { op: 0x4c, data }
+    return { op: 0x4c, data };
   }
   if (data.length <= 65535) {
     // Could have used OP_PUSHDATA2.
-    return { op: 0x4d, data }
+    return { op: 0x4d, data };
   }
-  return { op: 0x4e, data }
-}
+  return { op: 0x4e, data };
+};
 
 export default class PushDrop implements ScriptTemplate {
-  wallet: WalletInterface
+  wallet: WalletInterface;
 
   /**
    * Decodes a PushDrop script back into its token fields and the locking public key. If a signature was present, it will be the last field returned.
@@ -52,33 +60,38 @@ export default class PushDrop implements ScriptTemplate {
    * @param script PushDrop script to decode back into token fields
    * @returns An object containing PushDrop token fields and the locking public key. If a signature was included, it will be the last field.
    */
-  static decode(script: LockingScript): { lockingPublicKey: PublicKey, fields: number[][] } {
-    const lockingPublicKey = PublicKey.fromString(Utils.toHex(script.chunks[0].data))
-    const fields = []
+  static decode(script: LockingScript): {
+    lockingPublicKey: PublicKey;
+    fields: number[][];
+  } {
+    const lockingPublicKey = PublicKey.fromString(
+      Utils.toHex(script.chunks[0].data)
+    );
+    const fields = [];
     for (let i = 2; i < script.chunks.length; i++) {
-      const nextOpcode = script.chunks[i + 1].op
-      let chunk = script.chunks[i].data
+      const nextOpcode = script.chunks[i + 1].op;
+      let chunk = script.chunks[i].data;
       if (!chunk) {
         if (script.chunks[i].op >= 80 && script.chunks[i].op <= 95) {
-          chunk = [script.chunks[i].op - 80]
+          chunk = [script.chunks[i].op - 80];
         } else if (script.chunks[i].op === 0) {
-          chunk = [0]
+          chunk = [0];
         } else if (script.chunks[i].op === 0x4f) {
-          chunk = [0x81]
+          chunk = [0x81];
         }
       }
-      fields.push(chunk)
+      fields.push(chunk);
 
       // If the next value is DROP or 2DROP then this is the final field
       if (nextOpcode === OP.OP_DROP || nextOpcode === OP.OP_2DROP) {
-        break
+        break;
       }
     }
 
     return {
       fields,
-      lockingPublicKey
-    }
+      lockingPublicKey,
+    };
   }
 
   /**
@@ -87,7 +100,7 @@ export default class PushDrop implements ScriptTemplate {
    * @param {WalletInterface} wallet - The wallet interface used for creating signatures and accessing public keys.
    */
   constructor(wallet: WalletInterface) {
-    this.wallet = wallet
+    this.wallet = wallet;
   }
 
   /**
@@ -101,48 +114,53 @@ export default class PushDrop implements ScriptTemplate {
    * @param {boolean} [includeSignature=true] - Flag indicating if a signature should be included in the script (default yes).
    * @returns {Promise<LockingScript>} The generated PushDrop locking script.
    */
-  async lock(fields: number[][], protocolID: [SecurityLevel, string], keyID: string, counterparty: string, forSelf = false, includeSignature = true, lockPosition: 'before' | 'after' = 'before'): Promise<LockingScript> {
+  async lock(
+    fields: number[][],
+    protocolID: [SecurityLevel, string],
+    keyID: string,
+    counterparty: string,
+    forSelf = false,
+    includeSignature = true,
+    lockPosition: "before" | "after" = "before"
+  ): Promise<LockingScript> {
     const { publicKey } = await this.wallet.getPublicKey({
       protocolID,
       keyID,
       counterparty,
-      forSelf
-    })
-    const lockChunks: Array<{ op: number, data?: number[] }> = []
-    const pushDropChunks: Array<{ op: number, data?: number[] }> = []
-    lockChunks.push({ op: publicKey.length / 2, data: Utils.toArray(publicKey, 'hex') })
-    lockChunks.push({ op: OP.OP_CHECKSIG })
+      forSelf,
+    });
+    const lockChunks: Array<{ op: number; data?: number[] }> = [];
+    const pushDropChunks: Array<{ op: number; data?: number[] }> = [];
+    lockChunks.push({
+      op: publicKey.length / 2,
+      data: Utils.toArray(publicKey, "hex"),
+    });
+    lockChunks.push({ op: OP.OP_CHECKSIG });
     if (includeSignature) {
-      const dataToSign = fields.reduce((a, e) => [...a, ...e], [])
+      const dataToSign = fields.reduce((a, e) => [...a, ...e], []);
       const { signature } = await this.wallet.createSignature({
         data: dataToSign,
         protocolID,
         keyID,
-        counterparty
-      })
-      fields.push(signature)
+        counterparty,
+      });
+      fields.push(signature);
     }
     for (const field of fields) {
-      pushDropChunks.push(createMinimallyEncodedScriptChunk(field))
+      pushDropChunks.push(createMinimallyEncodedScriptChunk(field));
     }
-    let notYetDropped = fields.length
+    let notYetDropped = fields.length;
     while (notYetDropped > 1) {
-      pushDropChunks.push({ op: OP.OP_2DROP })
-      notYetDropped -= 2
+      pushDropChunks.push({ op: OP.OP_2DROP });
+      notYetDropped -= 2;
     }
     if (notYetDropped) {
-      pushDropChunks.push({ op: OP.OP_DROP })
+      pushDropChunks.push({ op: OP.OP_DROP });
     }
-    if (lockPosition === 'before') {
-      return new LockingScript([
-        ...lockChunks,
-        ...pushDropChunks
-      ])
+    if (lockPosition === "before") {
+      return new LockingScript([...lockChunks, ...pushDropChunks]);
     } else {
-      return new LockingScript([
-        ...pushDropChunks,
-        ...lockChunks
-      ])
+      return new LockingScript([...pushDropChunks, ...lockChunks]);
     }
   }
 
@@ -163,51 +181,61 @@ export default class PushDrop implements ScriptTemplate {
     protocolID: [SecurityLevel, string],
     keyID: string,
     counterparty: string,
-    signOutputs: 'all' | 'none' | 'single' = 'all',
+    signOutputs: "all" | "none" | "single" = "all",
     anyoneCanPay = false,
     sourceSatoshis?: number,
     lockingScript?: LockingScript
   ): {
-    sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>
-    estimateLength: () => Promise<73>
+    sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>;
+    estimateLength: () => Promise<73>;
   } {
     return {
-      sign: async (tx: Transaction, inputIndex: number): Promise<UnlockingScript> => {
-        let signatureScope = TransactionSignature.SIGHASH_FORKID
-        if (signOutputs === 'all') {
-          signatureScope |= TransactionSignature.SIGHASH_ALL
+      sign: async (
+        tx: Transaction,
+        inputIndex: number
+      ): Promise<UnlockingScript> => {
+        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 input = tx.inputs[inputIndex]
+        const input = tx.inputs[inputIndex];
 
-        const otherInputs = tx.inputs.filter((_, index) => index !== inputIndex)
+        const otherInputs = tx.inputs.filter(
+          (_, index) => index !== inputIndex
+        );
 
-        const sourceTXID = input.sourceTXID ? input.sourceTXID : input.sourceTransaction?.id('hex')
+        const sourceTXID = input.sourceTXID
+          ? input.sourceTXID
+          : input.sourceTransaction?.id("hex");
         if (!sourceTXID) {
           throw new Error(
-            'The input sourceTXID or sourceTransaction is required for transaction signing.'
-          )
+            "The input sourceTXID or sourceTransaction is required for transaction signing."
+          );
         }
-        sourceSatoshis ||= input.sourceTransaction?.outputs[input.sourceOutputIndex].satoshis
+        sourceSatoshis ||=
+          input.sourceTransaction?.outputs[input.sourceOutputIndex].satoshis;
         if (!sourceSatoshis) {
           throw new Error(
-            'The sourceSatoshis or input sourceTransaction is required for transaction signing.'
-          )
+            "The sourceSatoshis or input sourceTransaction is required for transaction signing."
+          );
         }
-        lockingScript ||= input.sourceTransaction?.outputs[input.sourceOutputIndex].lockingScript
+        lockingScript ||=
+          input.sourceTransaction?.outputs[input.sourceOutputIndex]
+            .lockingScript;
         if (!lockingScript) {
           throw new Error(
-            'The lockingScript or input sourceTransaction is required for transaction signing.'
-          )
+            "The lockingScript or input sourceTransaction is required for transaction signing."
+          );
         }
 
         const preimage = TransactionSignature.format({
@@ -221,27 +249,27 @@ export default class PushDrop implements ScriptTemplate {
           inputSequence: input.sequence,
           subscript: lockingScript,
           lockTime: tx.lockTime,
-          scope: signatureScope
-        })
-        const preimageHash = Hash.sha256(preimage)
+          scope: signatureScope,
+        });
+        const preimageHash = Hash.sha256(preimage);
         const { signature: bareSignature } = await this.wallet.createSignature({
           data: preimageHash,
           protocolID,
           keyID,
-          counterparty
-        })
-        const signature = Signature.fromDER([...bareSignature])
+          counterparty,
+        });
+        const signature = Signature.fromDER([...bareSignature]);
         const txSignature = new TransactionSignature(
           signature.r,
           signature.s,
           signatureScope
-        )
-        const sigForScript = txSignature.toChecksigFormat()
+        );
+        const sigForScript = txSignature.toChecksigFormat();
         return new UnlockingScript([
-          { op: sigForScript.length, data: sigForScript }
-        ])
+          { op: sigForScript.length, data: sigForScript },
+        ]);
       },
-      estimateLength: async () => 73
-    }
+      estimateLength: async () => 73,
+    };
   }
 }