@bsv/wallet-toolbox 1.3.28 → 1.3.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/wallet-toolbox",
-  "version": "1.3.28",
+  "version": "1.3.30",
   "description": "BRC100 conforming wallet, wallet storage and wallet signer components",
   "main": "./out/src/index.js",
   "types": "./out/src/index.d.ts",

package/src/monitor/Monitor.ts

@@ -221,7 +221,7 @@ export class Monitor {
           if (this.storage.getActive().isStorageProvider()) {
             const log = await ttr.runTask()
             if (log && log.length > 0) {
-              console.log(`Task${ttr.name} ${log}`)
+              console.log(`Task${ttr.name} ${log.slice(0, 80)}`)
               await this.logEvent(ttr.name, log)
             }
           }

package/src/sdk/WalletServices.interfaces.ts

@@ -173,7 +173,7 @@ export interface WalletServices {
    * @param reset if true, ends current interval and starts a new one.
    * @returns a history of service calls made to the configured services.
    */
-  getServicesCallHistory(reset?: boolean) : ServicesCallHistory
+  getServicesCallHistory(reset?: boolean): ServicesCallHistory
 }
 
 export type ScriptHashFormat = 'hashLE' | 'hashBE' | 'script'
@@ -539,7 +539,7 @@ export interface ServiceCall {
   /**
    * Error code and message iff success is false and a exception was thrown.
    */
-  error?: { message: string, code: string }
+  error?: { message: string; code: string }
 }
 
 /**

package/src/services/ServiceCollection.ts

@@ -1,5 +1,5 @@
-import { WalletError } from "../sdk/WalletError";
-import { ProviderCallHistory, ServiceCallHistory } from "../sdk/WalletServices.interfaces";
+import { WalletError } from '../sdk/WalletError'
+import { ProviderCallHistory, ServiceCallHistory } from '../sdk/WalletServices.interfaces'
 
 const MAX_RESET_COUNTS = 32
 const MAX_CALL_HISTORY = 32
@@ -14,7 +14,10 @@ export class ServiceCollection<T> {
   readonly since: Date
   _historyByProvider: Record<string, ProviderCallHistory> = {}
 
-  constructor(public serviceName: string, services?: { name: string; service: T }[]) {
+  constructor(
+    public serviceName: string,
+    services?: { name: string; service: T }[]
+  ) {
     this.services = services || []
     this._index = 0
     this.since = new Date()
@@ -37,19 +40,21 @@ export class ServiceCollection<T> {
     return this.services[this._index].service
   }
 
-  get serviceToCall(): ServiceToCall<T> {
-    const i = this._index
+  getServiceToCall(i: number): ServiceToCall<T> {
     const name = this.services[i].name
     const service = this.services[i].service
     const call = { name, when: new Date(), msecs: 0, success: false, result: undefined, error: undefined }
     return { serviceName: this.serviceName, providerName: name, service, call }
   }
 
+  get serviceToCall(): ServiceToCall<T> {
+    return this.getServiceToCall(this._index)
+  }
+
   get allServicesToCall(): ServiceToCall<T>[] {
     const all: ServiceToCall<T>[] = []
     for (let i = 0; i < this.services.length; i++) {
-      all.push(this.serviceToCall)
-      this.next()
+      all.push(this.getServiceToCall(i))
     }
     return all
   }
@@ -92,7 +97,7 @@ export class ServiceCollection<T> {
       this._historyByProvider[providerName] = h
     }
     h.calls.unshift(call)
-    h.calls = h.calls.slice(0,MAX_CALL_HISTORY)
+    h.calls = h.calls.slice(0, MAX_CALL_HISTORY)
     h.totalCounts.until = now
     h.resetCounts[0].until = now
     return h
@@ -220,7 +225,7 @@ export interface ServiceCall {
   /**
    * Error code and message iff success is false and a exception was thrown.
    */
-  error?: { message: string, code: string }
+  error?: { message: string; code: string }
 }
 
 export interface ServiceToCall<T> {
@@ -228,4 +233,4 @@ export interface ServiceToCall<T> {
   serviceName: string
   service: T
   call: ServiceCall
-}
+}

package/src/services/Services.ts

@@ -1,6 +1,6 @@
 import { Transaction as BsvTransaction, Beef, ChainTracker, Utils } from '@bsv/sdk'
 import { asArray, asString, doubleSha256BE, sdk, sha256Hash, TableOutput, wait } from '../index.client'
-import { ServiceCollection } from './ServiceCollection'
+import { ServiceCollection, ServiceToCall } from './ServiceCollection'
 import { createDefaultWalletServicesOptions } from './createDefaultWalletServicesOptions'
 import { ChaintracksChainTracker } from './chaintracker'
 import { WhatsOnChain } from './providers/WhatsOnChain'
@@ -40,7 +40,7 @@ export class Services implements sdk.WalletServices {
 
     this.arcTaal = new ARC(this.options.arcUrl, this.options.arcConfig, 'arcTaal')
     if (this.options.arcGorillaPoolUrl) {
-      //this.arcGorillaPool = new ARC(this.options.arcGorillaPoolUrl, this.options.arcGorillaPoolConfig, 'arcGorillaPool')
+      this.arcGorillaPool = new ARC(this.options.arcGorillaPoolUrl, this.options.arcGorillaPoolConfig, 'arcGorillaPool')
     }
 
     this.bitails = new Bitails(this.chain)
@@ -57,13 +57,13 @@ export class Services implements sdk.WalletServices {
     this.postBeefServices = new ServiceCollection<sdk.PostBeefService>('postBeef')
     if (this.arcGorillaPool) {
       //prettier-ignore
-      this.postBeefServices.add({ name: 'GorillaPool', service: this.arcGorillaPool.postBeef.bind(this.arcGorillaPool) })
+      this.postBeefServices.add({ name: 'GorillaPoolArcBeef', service: this.arcGorillaPool.postBeef.bind(this.arcGorillaPool) })
     }
     //prettier-ignore
     this.postBeefServices
       .add({ name: 'TaalArcBeef', service: this.arcTaal.postBeef.bind(this.arcTaal) })
-      .add({ name: 'WhatsOnChain', service: this.whatsonchain.postBeef.bind(this.whatsonchain) })
       .add({ name: 'Bitails', service: this.bitails.postBeef.bind(this.bitails) })
+      .add({ name: 'WhatsOnChain', service: this.whatsonchain.postBeef.bind(this.whatsonchain) })
       ;
 
     //prettier-ignore
@@ -84,7 +84,7 @@ export class Services implements sdk.WalletServices {
       .add({ name: 'exchangeratesapi', service: updateExchangeratesapi })
   }
 
-  getServicesCallHistory(reset?: boolean) : ServicesCallHistory {
+  getServicesCallHistory(reset?: boolean): ServicesCallHistory {
     return {
       version: 2,
       getMerklePath: this.getMerklePathServices.getServiceCallHistory(reset),
@@ -155,10 +155,8 @@ export class Services implements sdk.WalletServices {
           r0 = r
           break
         } else {
-          if (r.error)
-            services.addServiceCallError(stc, r.error)
-          else
-            services.addServiceCallFailure(stc)
+          if (r.error) services.addServiceCallError(stc, r.error)
+          else services.addServiceCallFailure(stc)
         }
       } catch (eu: unknown) {
         const e = sdk.WalletError.fromUnknown(eu)
@@ -217,10 +215,8 @@ export class Services implements sdk.WalletServices {
             r0 = r
             break
           } else {
-            if (r.error)
-              services.addServiceCallError(stc, r.error)
-            else
-              services.addServiceCallFailure(stc)
+            if (r.error) services.addServiceCallError(stc, r.error)
+            else services.addServiceCallFailure(stc)
           }
         } catch (eu: unknown) {
           const e = sdk.WalletError.fromUnknown(eu)
@@ -253,10 +249,8 @@ export class Services implements sdk.WalletServices {
           r0 = r
           break
         } else {
-          if (r.error)
-            services.addServiceCallError(stc, r.error)
-          else
-            services.addServiceCallFailure(stc)
+          if (r.error) services.addServiceCallError(stc, r.error)
+          else services.addServiceCallFailure(stc)
         }
       } catch (eu: unknown) {
         const e = sdk.WalletError.fromUnknown(eu)
@@ -267,6 +261,8 @@ export class Services implements sdk.WalletServices {
     return r0
   }
 
+  postBeefMode: 'PromiseAll' | 'UntilSuccess' = 'UntilSuccess'
+
   /**
    *
    * @param beef
@@ -274,24 +270,45 @@ export class Services implements sdk.WalletServices {
    * @returns
    */
   async postBeef(beef: Beef, txids: string[]): Promise<sdk.PostBeefResult[]> {
+    let rs: sdk.PostBeefResult[] = []
     const services = this.postBeefServices
     const stcs = services.allServicesToCall
-    let rs = await Promise.all(
-      stcs.map(async stc => {
-        const r = await stc.service(beef, txids)
-        if (r.status === 'success') {
-          services.addServiceCallSuccess(stc)
-        } else {
-          if (r.error) {
-            services.addServiceCallError(stc, r.error)
-          } else {
-            services.addServiceCallFailure(stc)
+    switch (this.postBeefMode) {
+      case 'UntilSuccess':
+        {
+          for (const stc of stcs) {
+            const r = await callService(stc)
+            rs.push(r)
+            if (r.status === 'success') break
           }
         }
-        return r
-      })
-    )
+        break
+      case 'PromiseAll':
+        {
+          rs = await Promise.all(
+            stcs.map(async stc => {
+              const r = await callService(stc)
+              return r
+            })
+          )
+        }
+        break
+    }
     return rs
+
+    async function callService(stc: ServiceToCall<sdk.PostBeefService>) {
+      const r = await stc.service(beef, txids)
+      if (r.status === 'success') {
+        services.addServiceCallSuccess(stc)
+      } else {
+        if (r.error) {
+          services.addServiceCallError(stc, r.error)
+        } else {
+          services.addServiceCallFailure(stc)
+        }
+      }
+      return r
+    }
   }
 
   async getRawTx(txid: string, useNext?: boolean): Promise<sdk.GetRawTxResult> {
@@ -319,17 +336,13 @@ export class Services implements sdk.WalletServices {
           r.rawTx = undefined
         }
 
-        if (r.error)
-          services.addServiceCallError(stc, r.error)
-        else if (!r.rawTx)
-          services.addServiceCallSuccess(stc, `not found`)
-        else
-          services.addServiceCallFailure(stc)
+        if (r.error) services.addServiceCallError(stc, r.error)
+        else if (!r.rawTx) services.addServiceCallSuccess(stc, `not found`)
+        else services.addServiceCallFailure(stc)
 
         if (r.error && !r0.error && !r0.rawTx)
           // If we have an error and didn't before...
           r0.error = r.error
-
       } catch (eu: unknown) {
         const e = sdk.WalletError.fromUnknown(eu)
         services.addServiceCallError(stc, e)
@@ -401,11 +414,9 @@ export class Services implements sdk.WalletServices {
           services.addServiceCallSuccess(stc)
           break
         }
-        
-        if (r.error)
-          services.addServiceCallError(stc, r.error)
-        else
-          services.addServiceCallFailure(stc)
+
+        if (r.error) services.addServiceCallError(stc, r.error)
+        else services.addServiceCallFailure(stc)
 
         if (r.error && !r0.error) {
           // If we have an error and didn't before...

package/src/services/createDefaultWalletServicesOptions.ts

@@ -7,10 +7,7 @@ export function createDefaultWalletServicesOptions(chain: sdk.Chain): sdk.Wallet
     chain === 'main'
       ? 'mainnet_9596de07e92300c6287e4393594ae39c' // no plan
       : 'testnet_0e6cf72133b43ea2d7861da2a38684e3' // personal "starter" key
-  const gorillaPoolApiKey =
-    chain === 'main'
-      ? ''
-      : ''
+  const gorillaPoolApiKey = chain === 'main' ? '' : ''
 
   const o: sdk.WalletServicesOptions = {
     chain,

package/src/signer/methods/completeSignedTransaction.ts

@@ -0,0 +1,115 @@
+import { Beef, SignActionResult, SignActionSpend, Spend, Transaction } from '@bsv/sdk'
+import { PendingSignAction, Wallet } from '../../Wallet'
+import { asBsvSdkScript, ScriptTemplateBRC29, sdk } from '../../index.client'
+import { WalletError, WERR_INTERNAL, WERR_INVALID_PARAMETER } from '../../sdk'
+
+export async function completeSignedTransaction(
+  prior: PendingSignAction,
+  spends: Record<number, SignActionSpend>,
+  wallet: Wallet
+): Promise<Transaction> {
+  /////////////////////
+  // Insert the user provided unlocking scripts from "spends" arg
+  /////////////////////
+  for (const [key, spend] of Object.entries(spends)) {
+    const vin = Number(key)
+    const createInput = prior.args.inputs[vin]
+    const input = prior.tx.inputs[vin]
+    if (!createInput || !input || createInput.unlockingScript || !Number.isInteger(createInput.unlockingScriptLength))
+      throw new sdk.WERR_INVALID_PARAMETER(
+        'args',
+        `spend does not correspond to prior input with valid unlockingScriptLength.`
+      )
+    if (spend.unlockingScript.length / 2 > createInput.unlockingScriptLength!)
+      throw new sdk.WERR_INVALID_PARAMETER(
+        'args',
+        `spend unlockingScript length ${spend.unlockingScript.length} exceeds expected length ${createInput.unlockingScriptLength}`
+      )
+    input.unlockingScript = asBsvSdkScript(spend.unlockingScript)
+    if (spend.sequenceNumber !== undefined) input.sequence = spend.sequenceNumber
+  }
+
+  const results = {
+    sdk: <SignActionResult>{}
+  }
+
+  /////////////////////
+  // Insert SABPPP unlock templates for wallet signed inputs
+  /////////////////////
+  for (const pdi of prior.pdi) {
+    const sabppp = new ScriptTemplateBRC29({
+      derivationPrefix: pdi.derivationPrefix,
+      derivationSuffix: pdi.derivationSuffix,
+      keyDeriver: wallet.keyDeriver
+    })
+    const keys = wallet.getClientChangeKeyPair()
+    const lockerPrivKey = keys.privateKey
+    const unlockerPubKey = pdi.unlockerPubKey || keys.publicKey
+    const sourceSatoshis = pdi.sourceSatoshis
+    const lockingScript = asBsvSdkScript(pdi.lockingScript)
+    const unlockTemplate = sabppp.unlock(lockerPrivKey, unlockerPubKey, sourceSatoshis, lockingScript)
+    const input = prior.tx.inputs[pdi.vin]
+    input.unlockingScriptTemplate = unlockTemplate
+  }
+
+  /////////////////////
+  // Sign wallet signed inputs making transaction fully valid.
+  /////////////////////
+  await prior.tx.sign()
+
+  return prior.tx
+}
+
+/**
+ * @param txid The TXID of a transaction in the beef for which all unlocking scripts must be valid.
+ * @param beef Must contain transactions for txid and all its inputs.
+ * @throws WERR_INVALID_PARAMETER if any unlocking script is invalid, if sourceTXID is invalid, if beef doesn't contain required transactions.
+ */
+export function verifyUnlockScripts(txid: string, beef: Beef): void {
+  const tx = beef.findTxid(txid)?.tx
+  if (!tx) throw new WERR_INVALID_PARAMETER(`txid`, `contained in beef, txid ${txid}`)
+
+  for (let i = 0; i < tx.inputs.length; i++) {
+    const input = tx.inputs[i]
+    if (!input.sourceTXID) throw new WERR_INVALID_PARAMETER(`inputs[${i}].sourceTXID`, `valid`)
+    if (!input.unlockingScript) throw new WERR_INVALID_PARAMETER(`inputs[${i}].unlockingScript`, `valid`)
+    input.sourceTransaction = beef.findTxid(input.sourceTXID)?.tx
+    if (!input.sourceTransaction) {
+      // The beef doesn't contain all the source transactions only if advanced features
+      // such as knownTxids are used.
+      // Skip unlock script checks.
+      return
+      // throw new WERR_INVALID_PARAMETER(`inputs[${i}].sourceTXID`, `contained in beef`)
+    }
+  }
+
+  for (let i = 0; i < tx.inputs.length; i++) {
+    const input = tx.inputs[i]
+    const sourceOutput = input.sourceTransaction!.outputs[input.sourceOutputIndex]
+
+    const otherInputs = tx.inputs.filter((_, idx) => idx !== i)
+
+    const spend = new Spend({
+      sourceTXID: input.sourceTXID!,
+      sourceOutputIndex: input.sourceOutputIndex,
+      lockingScript: sourceOutput.lockingScript,
+      sourceSatoshis: sourceOutput.satoshis ?? 0,
+      transactionVersion: tx.version,
+      otherInputs,
+      unlockingScript: input.unlockingScript!,
+      inputSequence: input.sequence ?? 0,
+      inputIndex: i,
+      outputs: tx.outputs,
+      lockTime: tx.lockTime
+    })
+
+    try {
+      const spendValid = spend.validate()
+
+      if (!spendValid) throw new WERR_INVALID_PARAMETER(`inputs[${i}].unlockScript`, `valid`)
+    } catch (eu: unknown) {
+      const e = WalletError.fromUnknown(eu)
+      throw new WERR_INVALID_PARAMETER(`inputs[${i}].unlockScript`, `valid. ${e.message}`)
+    }
+  }
+}

package/src/signer/methods/createAction.ts

@@ -5,22 +5,13 @@ import {
   OutpointString,
   SendWithResult,
   SignableTransaction,
-  SignActionResult,
-  SignActionSpend,
   TXIDHexString
 } from '@bsv/sdk'
 import { Script, Transaction } from '@bsv/sdk'
-import {
-  asBsvSdkScript,
-  makeAtomicBeef,
-  PendingSignAction,
-  ScriptTemplateBRC29,
-  sdk,
-  verifyTruthy,
-  Wallet
-} from '../../index.client'
+import { makeAtomicBeef, PendingSignAction, ScriptTemplateBRC29, sdk, verifyTruthy, Wallet } from '../../index.client'
 import { buildSignableTransaction } from './buildSignableTransaction'
 import { ReviewActionResult } from '../../sdk/WalletStorage.interfaces'
+import { completeSignedTransaction, verifyUnlockScripts } from './completeSignedTransaction'
 
 export interface CreateActionResultX extends CreateActionResult {
   txid?: TXIDHexString
@@ -50,8 +41,14 @@ export async function createAction(
     prior.tx = await completeSignedTransaction(prior, {}, wallet)
 
     r.txid = prior.tx.id('hex')
+    const beef = new Beef()
+    if (prior.dcr.inputBeef) beef.mergeBeef(prior.dcr.inputBeef)
+    beef.mergeTransaction(prior.tx)
+
+    verifyUnlockScripts(r.txid, beef)
+
     r.noSendChange = prior.dcr.noSendChangeOutputVouts?.map(vout => `${r.txid}.${vout}`)
-    if (!vargs.options.returnTXIDOnly) r.tx = makeAtomicBeef(prior.tx, prior.dcr.inputBeef!)
+    if (!vargs.options.returnTXIDOnly) r.tx = beef.toBinaryAtomic(r.txid)
   }
 
   const { sendWithResults, notDelayedResults } = await processAction(prior, wallet, auth, vargs)
@@ -131,62 +128,6 @@ export function makeChangeLock(
   return lockingScript
 }
 
-export async function completeSignedTransaction(
-  prior: PendingSignAction,
-  spends: Record<number, SignActionSpend>,
-  wallet: Wallet
-): Promise<Transaction> {
-  /////////////////////
-  // Insert the user provided unlocking scripts from "spends" arg
-  /////////////////////
-  for (const [key, spend] of Object.entries(spends)) {
-    const vin = Number(key)
-    const createInput = prior.args.inputs[vin]
-    const input = prior.tx.inputs[vin]
-    if (!createInput || !input || createInput.unlockingScript || !Number.isInteger(createInput.unlockingScriptLength))
-      throw new sdk.WERR_INVALID_PARAMETER(
-        'args',
-        `spend does not correspond to prior input with valid unlockingScriptLength.`
-      )
-    if (spend.unlockingScript.length / 2 > createInput.unlockingScriptLength!)
-      throw new sdk.WERR_INVALID_PARAMETER(
-        'args',
-        `spend unlockingScript length ${spend.unlockingScript.length} exceeds expected length ${createInput.unlockingScriptLength}`
-      )
-    input.unlockingScript = asBsvSdkScript(spend.unlockingScript)
-    if (spend.sequenceNumber !== undefined) input.sequence = spend.sequenceNumber
-  }
-
-  const results = {
-    sdk: <SignActionResult>{}
-  }
-
-  /////////////////////
-  // Insert SABPPP unlock templates for storage signed inputs
-  /////////////////////
-  for (const pdi of prior.pdi) {
-    const sabppp = new ScriptTemplateBRC29({
-      derivationPrefix: pdi.derivationPrefix,
-      derivationSuffix: pdi.derivationSuffix,
-      keyDeriver: wallet.keyDeriver
-    })
-    const keys = wallet.getClientChangeKeyPair()
-    const lockerPrivKey = keys.privateKey
-    const unlockerPubKey = pdi.unlockerPubKey || keys.publicKey
-    const sourceSatoshis = pdi.sourceSatoshis
-    const lockingScript = asBsvSdkScript(pdi.lockingScript)
-    const unlockTemplate = sabppp.unlock(lockerPrivKey, unlockerPubKey, sourceSatoshis, lockingScript)
-    const input = prior.tx.inputs[pdi.vin]
-    input.unlockingScriptTemplate = unlockTemplate
-  }
-
-  /////////////////////
-  // Sign storage signed inputs making transaction fully valid.
-  /////////////////////
-  await prior.tx.sign()
-
-  return prior.tx
-}
 function removeUnlockScripts(args: sdk.ValidCreateActionArgs) {
   let storageArgs = args
   if (!storageArgs.inputs.every(i => i.unlockingScript === undefined)) {

package/src/signer/methods/signAction.ts

@@ -1,20 +1,10 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-
-import {
-  AtomicBEEF,
-  Beef,
-  Transaction as BsvTransaction,
-  SendWithResult,
-  SignActionArgs,
-  SignActionOptions,
-  SignActionResult,
-  SignActionSpend,
-  TXIDHexString
-} from '@bsv/sdk'
-import { asBsvSdkScript, PendingSignAction, ScriptTemplateBRC29, sdk, Wallet } from '../../index.client'
+import { AtomicBEEF, Beef, SendWithResult, SignActionArgs, SignActionResult, TXIDHexString } from '@bsv/sdk'
+import { sdk, Wallet } from '../../index.client'
 import { processAction } from './createAction'
 import { ReviewActionResult } from '../../sdk/WalletStorage.interfaces'
 import { validateSignActionArgs } from '../../sdk'
+import { completeSignedTransaction, verifyUnlockScripts } from './completeSignedTransaction'
+import { makeAtomicBeef } from '../../utility/utilityHelpers'
 
 export interface SignActionResultX extends SignActionResult {
   txid?: TXIDHexString
@@ -35,9 +25,15 @@ export async function signAction(wallet: Wallet, auth: sdk.AuthId, args: SignAct
 
   const { sendWithResults, notDelayedResults } = await processAction(prior, wallet, auth, vargs)
 
+  const txid = prior.tx.id('hex')
+  const beef = Beef.fromBinary(prior.dcr.inputBeef)
+  beef.mergeTransaction(prior.tx)
+
+  verifyUnlockScripts(txid, beef)
+
   const r: SignActionResultX = {
     txid: prior.tx.id('hex'),
-    tx: vargs.options.returnTXIDOnly ? undefined : makeAtomicBeef(prior.tx, prior.dcr.inputBeef),
+    tx: vargs.options.returnTXIDOnly ? undefined : beef.toBinaryAtomic(txid),
     sendWithResults,
     notDelayedResults
   }
@@ -45,69 +41,6 @@ export async function signAction(wallet: Wallet, auth: sdk.AuthId, args: SignAct
   return r
 }
 
-export function makeAtomicBeef(tx: BsvTransaction, beef: number[] | Beef): number[] {
-  if (Array.isArray(beef)) beef = Beef.fromBinary(beef)
-  beef.mergeTransaction(tx)
-  return beef.toBinaryAtomic(tx.id('hex'))
-}
-
-export async function completeSignedTransaction(
-  prior: PendingSignAction,
-  spends: Record<number, SignActionSpend>,
-  wallet: Wallet
-): Promise<BsvTransaction> {
-  /////////////////////
-  // Insert the user provided unlocking scripts from "spends" arg
-  /////////////////////
-  for (const [key, spend] of Object.entries(spends)) {
-    const vin = Number(key)
-    const createInput = prior.args.inputs[vin]
-    const input = prior.tx.inputs[vin]
-    if (!createInput || !input || createInput.unlockingScript || !Number.isInteger(createInput.unlockingScriptLength))
-      throw new sdk.WERR_INVALID_PARAMETER(
-        'args',
-        `spend does not correspond to prior input with valid unlockingScriptLength.`
-      )
-    if (spend.unlockingScript.length / 2 > createInput.unlockingScriptLength!)
-      throw new sdk.WERR_INVALID_PARAMETER(
-        'args',
-        `spend unlockingScript length ${spend.unlockingScript.length} exceeds expected length ${createInput.unlockingScriptLength}`
-      )
-    input.unlockingScript = asBsvSdkScript(spend.unlockingScript)
-    if (spend.sequenceNumber !== undefined) input.sequence = spend.sequenceNumber
-  }
-
-  const results = {
-    sdk: <SignActionResult>{}
-  }
-
-  /////////////////////
-  // Insert SABPPP unlock templates for wallet signed inputs
-  /////////////////////
-  for (const pdi of prior.pdi) {
-    const sabppp = new ScriptTemplateBRC29({
-      derivationPrefix: pdi.derivationPrefix,
-      derivationSuffix: pdi.derivationSuffix,
-      keyDeriver: wallet.keyDeriver
-    })
-    const keys = wallet.getClientChangeKeyPair()
-    const lockerPrivKey = keys.privateKey
-    const unlockerPubKey = pdi.unlockerPubKey || keys.publicKey
-    const sourceSatoshis = pdi.sourceSatoshis
-    const lockingScript = asBsvSdkScript(pdi.lockingScript)
-    const unlockTemplate = sabppp.unlock(lockerPrivKey, unlockerPubKey, sourceSatoshis, lockingScript)
-    const input = prior.tx.inputs[pdi.vin]
-    input.unlockingScriptTemplate = unlockTemplate
-  }
-
-  /////////////////////
-  // Sign wallet signed inputs making transaction fully valid.
-  /////////////////////
-  await prior.tx.sign()
-
-  return prior.tx
-}
-
 function mergePriorOptions(caVargs: sdk.ValidCreateActionArgs, saArgs: SignActionArgs): sdk.ValidSignActionArgs {
   const saOptions = (saArgs.options ||= {})
   if (saOptions.acceptDelayedBroadcast === undefined)