@bsv/wallet-toolbox 1.1.59 → 1.1.61

package/src/sdk/validationHelpers.ts

@@ -84,15 +84,10 @@ function validateOptionalStringLength(
   return validateStringLength(s, name, min, max)
 }
 
-export function validateSatoshis(
-  v: number | undefined,
-  name: string,
-  min?: number
-): number {
+export function validateSatoshis(v: number | undefined, name: string, min?: number): number {
   if (v === undefined || !Number.isInteger(v) || v < 0 || v > 21e14)
     throw new sdk.WERR_INVALID_PARAMETER(name, 'a valid number of satoshis')
-  if (min !== undefined && v < min)
-    throw new sdk.WERR_INVALID_PARAMETER(name, `at least ${min} satoshis.`)
+  if (min !== undefined && v < min) throw new sdk.WERR_INVALID_PARAMETER(name, `at least ${min} satoshis.`)
   return v
 }
 
@@ -117,13 +112,10 @@ export function validateInteger(
     if (defaultValue !== undefined) return defaultValue
     throw new sdk.WERR_INVALID_PARAMETER(name, 'a valid integer')
   }
-  if (!Number.isInteger(v))
-    throw new sdk.WERR_INVALID_PARAMETER(name, 'an integer')
+  if (!Number.isInteger(v)) throw new sdk.WERR_INVALID_PARAMETER(name, 'an integer')
   v = Number(v)
-  if (min !== undefined && v < min)
-    throw new sdk.WERR_INVALID_PARAMETER(name, `at least ${min} length.`)
-  if (max !== undefined && v > max)
-    throw new sdk.WERR_INVALID_PARAMETER(name, `no more than ${max} length.`)
+  if (min !== undefined && v < min) throw new sdk.WERR_INVALID_PARAMETER(name, `at least ${min} length.`)
+  if (max !== undefined && v > max) throw new sdk.WERR_INVALID_PARAMETER(name, `no more than ${max} length.`)
   return v
 }
 
@@ -131,17 +123,10 @@ export function validatePositiveIntegerOrZero(v: number, name: string): number {
   return validateInteger(v, name, 0, 0)
 }
 
-export function validateStringLength(
-  s: string,
-  name: string,
-  min?: number,
-  max?: number
-): string {
+export function validateStringLength(s: string, name: string, min?: number, max?: number): string {
   const bytes = Utils.toArray(s, 'utf8').length
-  if (min !== undefined && bytes < min)
-    throw new sdk.WERR_INVALID_PARAMETER(name, `at least ${min} length.`)
-  if (max !== undefined && bytes > max)
-    throw new sdk.WERR_INVALID_PARAMETER(name, `no more than ${max} length.`)
+  if (min !== undefined && bytes < min) throw new sdk.WERR_INVALID_PARAMETER(name, `at least ${min} length.`)
+  if (max !== undefined && bytes > max) throw new sdk.WERR_INVALID_PARAMETER(name, `no more than ${max} length.`)
   return s
 }
 
@@ -162,18 +147,11 @@ function validateTag(s: string): string {
   return validateIdentifier(s, 'tag', 1, 300)
 }
 
-function validateIdentifier(
-  s: string,
-  name: string,
-  min?: number,
-  max?: number
-): string {
+function validateIdentifier(s: string, name: string, min?: number, max?: number): string {
   s = s.trim().toLowerCase()
   const bytes = Utils.toArray(s, 'utf8').length
-  if (min !== undefined && bytes < min)
-    throw new sdk.WERR_INVALID_PARAMETER(name, `at least ${min} length.`)
-  if (max !== undefined && bytes > max)
-    throw new sdk.WERR_INVALID_PARAMETER(name, `no more than ${max} length.`)
+  if (min !== undefined && bytes < min) throw new sdk.WERR_INVALID_PARAMETER(name, `at least ${min} length.`)
+  if (max !== undefined && bytes > max) throw new sdk.WERR_INVALID_PARAMETER(name, `no more than ${max} length.`)
   return s
 }
 
@@ -187,31 +165,19 @@ function validateOptionalBase64String(
   return validateBase64String(s, name, min, max)
 }
 
-function validateBase64String(
-  s: string,
-  name: string,
-  min?: number,
-  max?: number
-): string {
+function validateBase64String(s: string, name: string, min?: number, max?: number): string {
   // Remove any whitespace and check if the string length is valid for Base64
   s = s.trim()
-  const base64Regex =
-    /^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{2}==|[A-Za-z0-9+\/]{3}=)?$/
+  const base64Regex = /^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{2}==|[A-Za-z0-9+\/]{3}=)?$/
   const paddingCount = (s.match(/=+$/) || [])[0]?.length || 0
 
-  if (
-    paddingCount > 2 ||
-    (s.length % 4 !== 0 && paddingCount !== 0) ||
-    !base64Regex.test(s)
-  ) {
+  if (paddingCount > 2 || (s.length % 4 !== 0 && paddingCount !== 0) || !base64Regex.test(s)) {
     throw new sdk.WERR_INVALID_PARAMETER(name, `balid base64 string`)
   }
 
   const bytes = Utils.toArray(s, 'base64').length
-  if (min !== undefined && bytes < min)
-    throw new sdk.WERR_INVALID_PARAMETER(name, `at least ${min} length.`)
-  if (max !== undefined && bytes > max)
-    throw new sdk.WERR_INVALID_PARAMETER(name, `no more than ${max} length.`)
+  if (min !== undefined && bytes < min) throw new sdk.WERR_INVALID_PARAMETER(name, `at least ${min} length.`)
+  if (max !== undefined && bytes > max) throw new sdk.WERR_INVALID_PARAMETER(name, `no more than ${max} length.`)
 
   return s
 }
@@ -233,22 +199,13 @@ function validateOptionalHexString(
  * @param max if valid, string length maximum (not bytes)
  * @returns
  */
-function validateHexString(
-  s: string,
-  name: string,
-  min?: number,
-  max?: number
-): string {
+function validateHexString(s: string, name: string, min?: number, max?: number): string {
   s = s.trim().toLowerCase()
-  if (s.length % 2 === 1)
-    throw new sdk.WERR_INVALID_PARAMETER(name, `even length, not ${s.length}.`)
+  if (s.length % 2 === 1) throw new sdk.WERR_INVALID_PARAMETER(name, `even length, not ${s.length}.`)
   const hexRegex = /^[0-9A-Fa-f]+$/
-  if (!hexRegex.test(s))
-    throw new sdk.WERR_INVALID_PARAMETER(name, `hexadecimal string.`)
-  if (min !== undefined && s.length < min)
-    throw new sdk.WERR_INVALID_PARAMETER(name, `at least ${min} length.`)
-  if (max !== undefined && s.length > max)
-    throw new sdk.WERR_INVALID_PARAMETER(name, `no more than ${max} length.`)
+  if (!hexRegex.test(s)) throw new sdk.WERR_INVALID_PARAMETER(name, `hexadecimal string.`)
+  if (min !== undefined && s.length < min) throw new sdk.WERR_INVALID_PARAMETER(name, `at least ${min} length.`)
+  if (max !== undefined && s.length > max) throw new sdk.WERR_INVALID_PARAMETER(name, `no more than ${max} length.`)
   return s
 }
 
@@ -276,33 +233,16 @@ export interface ValidCreateActionInput {
   unlockingScriptLength: PositiveInteger
 }
 
-export function validateCreateActionInput(
-  i: CreateActionInput
-): ValidCreateActionInput {
+export function validateCreateActionInput(i: CreateActionInput): ValidCreateActionInput {
   if (i.unlockingScript === undefined && i.unlockingScriptLength === undefined)
-    throw new sdk.WERR_INVALID_PARAMETER(
-      'unlockingScript, unlockingScriptLength',
-      `at least one valid value.`
-    )
-  const unlockingScript = validateOptionalHexString(
-    i.unlockingScript,
-    'unlockingScript'
-  )
-  const unlockingScriptLength =
-    i.unlockingScriptLength || unlockingScript!.length / 2
+    throw new sdk.WERR_INVALID_PARAMETER('unlockingScript, unlockingScriptLength', `at least one valid value.`)
+  const unlockingScript = validateOptionalHexString(i.unlockingScript, 'unlockingScript')
+  const unlockingScriptLength = i.unlockingScriptLength || unlockingScript!.length / 2
   if (unlockingScript && unlockingScriptLength !== unlockingScript.length / 2)
-    throw new sdk.WERR_INVALID_PARAMETER(
-      'unlockingScriptLength',
-      `length unlockingScript if both valid.`
-    )
+    throw new sdk.WERR_INVALID_PARAMETER('unlockingScriptLength', `length unlockingScript if both valid.`)
   const vi: ValidCreateActionInput = {
     outpoint: parseWalletOutpoint(i.outpoint),
-    inputDescription: validateStringLength(
-      i.inputDescription,
-      'inputDescription',
-      5,
-      2000
-    ),
+    inputDescription: validateStringLength(i.inputDescription, 'inputDescription', 5, 2000),
     unlockingScript,
     unlockingScriptLength,
     sequenceNumber: default0xffffffff(i.sequenceNumber)
@@ -319,18 +259,11 @@ export interface ValidCreateActionOutput {
   tags: BasketStringUnder300Bytes[]
 }
 
-export function validateCreateActionOutput(
-  o: CreateActionOutput
-): ValidCreateActionOutput {
+export function validateCreateActionOutput(o: CreateActionOutput): ValidCreateActionOutput {
   const vo: ValidCreateActionOutput = {
     lockingScript: validateHexString(o.lockingScript, 'lockingScript'),
     satoshis: validateSatoshis(o.satoshis, 'satoshis'),
-    outputDescription: validateStringLength(
-      o.outputDescription,
-      'outputDescription',
-      5,
-      2000
-    ),
+    outputDescription: validateStringLength(o.outputDescription, 'outputDescription', 5, 2000),
     basket: validateOptionalBasket(o.basket),
     customInstructions: o.customInstructions,
     tags: defaultEmpty(o.tags).map(t => validateTag(t))
@@ -344,9 +277,7 @@ export function validateCreateActionOutput(
  * Set all possibly undefined arrays to empty arrays.
  * Convert string outpoints to `{ txid: string, vout: number }`
  */
-export function validateCreateActionOptions(
-  options?: CreateActionOptions
-): ValidCreateActionOptions {
+export function validateCreateActionOptions(options?: CreateActionOptions): ValidCreateActionOptions {
   const o = options || {}
   const vo: ValidCreateActionOptions = {
     signAndProcess: defaultTrue(o.signAndProcess),
@@ -354,9 +285,7 @@ export function validateCreateActionOptions(
     knownTxids: defaultEmpty(o.knownTxids),
     returnTXIDOnly: defaultFalse(o.returnTXIDOnly),
     noSend: defaultFalse(o.noSend),
-    noSendChange: defaultEmpty(o.noSendChange).map(nsc =>
-      parseWalletOutpoint(nsc)
-    ),
+    noSendChange: defaultEmpty(o.noSendChange).map(nsc => parseWalletOutpoint(nsc)),
     sendWith: defaultEmpty(o.sendWith),
     randomizeOutputs: defaultTrue(o.randomizeOutputs)
   }
@@ -427,9 +356,7 @@ export interface ValidSignActionArgs extends ValidProcessActionArgs {
   options: sdk.ValidSignActionOptions
 }
 
-export function validateCreateActionArgs(
-  args: CreateActionArgs
-): ValidCreateActionArgs {
+export function validateCreateActionArgs(args: CreateActionArgs): ValidCreateActionArgs {
   const vargs: ValidCreateActionArgs = {
     description: validateStringLength(args.description, 'description', 5, 2000),
     inputBEEF: args.inputBEEF,
@@ -449,14 +376,10 @@ export function validateCreateActionArgs(
     includeAllSourceTransactions: false
   }
   vargs.isSendWith = vargs.options.sendWith.length > 0
-  vargs.isRemixChange =
-    !vargs.isSendWith && vargs.inputs.length === 0 && vargs.outputs.length === 0
-  vargs.isNewTx =
-    vargs.isRemixChange || vargs.inputs.length > 0 || vargs.outputs.length > 0
+  vargs.isRemixChange = !vargs.isSendWith && vargs.inputs.length === 0 && vargs.outputs.length === 0
+  vargs.isNewTx = vargs.isRemixChange || vargs.inputs.length > 0 || vargs.outputs.length > 0
   vargs.isSignAction =
-    vargs.isNewTx &&
-    (vargs.options.signAndProcess === false ||
-      vargs.inputs.some(i => i.unlockingScript === undefined))
+    vargs.isNewTx && (vargs.options.signAndProcess === false || vargs.inputs.some(i => i.unlockingScript === undefined))
   vargs.isDelayed = vargs.options.acceptDelayedBroadcast
   vargs.isNoSend = vargs.options.noSend
 
@@ -469,9 +392,7 @@ export function validateCreateActionArgs(
  * Set all possibly undefined arrays to empty arrays.
  * Convert string outpoints to `{ txid: string, vout: number }`
  */
-export function validateSignActionOptions(
-  options?: SignActionOptions
-): ValidSignActionOptions {
+export function validateSignActionOptions(options?: SignActionOptions): ValidSignActionOptions {
   const o = options || {}
   const vo: ValidSignActionOptions = {
     acceptDelayedBroadcast: defaultTrue(o.acceptDelayedBroadcast),
@@ -482,9 +403,7 @@ export function validateSignActionOptions(
   return vo
 }
 
-export function validateSignActionArgs(
-  args: SignActionArgs
-): ValidSignActionArgs {
+export function validateSignActionArgs(args: SignActionArgs): ValidSignActionArgs {
   const vargs: ValidSignActionArgs = {
     spends: args.spends,
     reference: args.reference,
@@ -506,9 +425,7 @@ export interface ValidAbortActionArgs extends ValidWalletSignerArgs {
   reference: Base64String
 }
 
-export function validateAbortActionArgs(
-  args: AbortActionArgs
-): ValidAbortActionArgs {
+export function validateAbortActionArgs(args: AbortActionArgs): ValidAbortActionArgs {
   const vargs: ValidAbortActionArgs = {
     reference: validateBase64String(args.reference, 'reference')
   }
@@ -522,23 +439,12 @@ export interface ValidWalletPayment {
   senderIdentityKey: PubKeyHex
 }
 
-export function validateWalletPayment(
-  args?: WalletPayment
-): ValidWalletPayment | undefined {
+export function validateWalletPayment(args?: WalletPayment): ValidWalletPayment | undefined {
   if (args === undefined) return undefined
   const v: ValidWalletPayment = {
-    derivationPrefix: validateBase64String(
-      args.derivationPrefix,
-      'derivationPrefix'
-    ),
-    derivationSuffix: validateBase64String(
-      args.derivationSuffix,
-      'derivationSuffix'
-    ),
-    senderIdentityKey: validateHexString(
-      args.senderIdentityKey,
-      'senderIdentityKey'
-    )
+    derivationPrefix: validateBase64String(args.derivationPrefix, 'derivationPrefix'),
+    derivationSuffix: validateBase64String(args.derivationSuffix, 'derivationSuffix'),
+    senderIdentityKey: validateHexString(args.senderIdentityKey, 'senderIdentityKey')
   }
   return v
 }
@@ -549,18 +455,11 @@ export interface ValidBasketInsertion {
   tags: BasketStringUnder300Bytes[]
 }
 
-export function validateBasketInsertion(
-  args?: BasketInsertion
-): ValidBasketInsertion | undefined {
+export function validateBasketInsertion(args?: BasketInsertion): ValidBasketInsertion | undefined {
   if (args === undefined) return undefined
   const v: ValidBasketInsertion = {
     basket: validateBasket(args.basket),
-    customInstructions: validateOptionalStringLength(
-      args.customInstructions,
-      'customInstructions',
-      0,
-      1000
-    ), // TODO: real max??
+    customInstructions: validateOptionalStringLength(args.customInstructions, 'customInstructions', 0, 1000), // TODO: real max??
     tags: defaultEmpty(args.tags).map(t => validateTag(t))
   }
   return v
@@ -573,17 +472,9 @@ export interface ValidInternalizeOutput {
   insertionRemittance?: ValidBasketInsertion
 }
 
-export function validateInternalizeOutput(
-  args: InternalizeOutput
-): ValidInternalizeOutput {
-  if (
-    args.protocol !== 'basket insertion' &&
-    args.protocol !== 'wallet payment'
-  )
-    throw new sdk.WERR_INVALID_PARAMETER(
-      'protocol',
-      `'basket insertion' or 'wallet payment'`
-    )
+export function validateInternalizeOutput(args: InternalizeOutput): ValidInternalizeOutput {
+  if (args.protocol !== 'basket insertion' && args.protocol !== 'wallet payment')
+    throw new sdk.WERR_INVALID_PARAMETER('protocol', `'basket insertion' or 'wallet payment'`)
   const v: ValidInternalizeOutput = {
     outputIndex: validatePositiveIntegerOrZero(args.outputIndex, 'outputIndex'),
     protocol: args.protocol,
@@ -611,9 +502,7 @@ export function validateOriginator(s?: string): string | undefined {
   }
 }
 
-export function validateInternalizeActionArgs(
-  args: InternalizeActionArgs
-): ValidInternalizeActionArgs {
+export function validateInternalizeActionArgs(args: InternalizeActionArgs): ValidInternalizeActionArgs {
   const vargs: ValidInternalizeActionArgs = {
     tx: args.tx,
     outputs: args.outputs.map(o => validateInternalizeOutput(o)),
@@ -625,29 +514,17 @@ export function validateInternalizeActionArgs(
   try {
     const beef = Beef.fromBinary(vargs.tx)
     if (beef.txs.length < 1)
-      throw new sdk.WERR_INVALID_PARAMETER(
-        'tx',
-        `at least one transaction to internalize an output from`
-      )
+      throw new sdk.WERR_INVALID_PARAMETER('tx', `at least one transaction to internalize an output from`)
   } catch {
-    throw new sdk.WERR_INVALID_PARAMETER(
-      'tx',
-      `valid with at least one transaction to internalize an output from`
-    )
+    throw new sdk.WERR_INVALID_PARAMETER('tx', `valid with at least one transaction to internalize an output from`)
   }
   if (vargs.outputs.length < 1)
-    throw new sdk.WERR_INVALID_PARAMETER(
-      'outputs',
-      `at least one output to internalize from the transaction`
-    )
+    throw new sdk.WERR_INVALID_PARAMETER('outputs', `at least one output to internalize from the transaction`)
 
   return vargs
 }
 
-export function validateOptionalOutpointString(
-  outpoint: string | undefined,
-  name: string
-): string | undefined {
+export function validateOptionalOutpointString(outpoint: string | undefined, name: string): string | undefined {
   if (outpoint === undefined) return undefined
   return validateOutpointString(outpoint, name)
 }
@@ -655,10 +532,7 @@ export function validateOptionalOutpointString(
 export function validateOutpointString(outpoint: string, name: string): string {
   const s = outpoint.split('.')
   if (s.length !== 2 || !Number.isInteger(Number(s[1])))
-    throw new sdk.WERR_INVALID_PARAMETER(
-      name,
-      `txid as hex string and numeric output index joined with '.'`
-    )
+    throw new sdk.WERR_INVALID_PARAMETER(name, `txid as hex string and numeric output index joined with '.'`)
   const txid = validateHexString(s[0], `${name} txid`, undefined, 64)
   const vout = validatePositiveIntegerOrZero(Number(s[1]), `${name} vout`)
   return `${txid}.${vout}`
@@ -669,9 +543,7 @@ export interface ValidRelinquishOutputArgs extends ValidWalletSignerArgs {
   output: OutpointString
 }
 
-export function validateRelinquishOutputArgs(
-  args: RelinquishOutputArgs
-): ValidRelinquishOutputArgs {
+export function validateRelinquishOutputArgs(args: RelinquishOutputArgs): ValidRelinquishOutputArgs {
   const vargs: ValidRelinquishOutputArgs = {
     basket: validateBasket(args.basket),
     output: validateOutpointString(args.output, 'output')
@@ -686,9 +558,7 @@ export interface ValidRelinquishCertificateArgs extends ValidWalletSignerArgs {
   certifier: PubKeyHex
 }
 
-export function validateRelinquishCertificateArgs(
-  args: RelinquishCertificateArgs
-): ValidRelinquishCertificateArgs {
+export function validateRelinquishCertificateArgs(args: RelinquishCertificateArgs): ValidRelinquishCertificateArgs {
   const vargs: ValidRelinquishCertificateArgs = {
     type: validateBase64String(args.type, 'type'),
     serialNumber: validateBase64String(args.serialNumber, 'serialNumber'),
@@ -715,25 +585,14 @@ export interface ValidListCertificatesArgs extends ValidWalletSignerArgs {
   privilegedReason?: DescriptionString5to50Bytes
 }
 
-export function validateListCertificatesArgs(
-  args: ListCertificatesArgs
-): ValidListCertificatesArgs {
+export function validateListCertificatesArgs(args: ListCertificatesArgs): ValidListCertificatesArgs {
   const vargs: ValidListCertificatesArgs = {
-    certifiers: defaultEmpty(
-      args.certifiers.map(c => validateHexString(c.trim(), 'certifiers'))
-    ),
-    types: defaultEmpty(
-      args.types.map(t => validateBase64String(t.trim(), 'types'))
-    ),
+    certifiers: defaultEmpty(args.certifiers.map(c => validateHexString(c.trim(), 'certifiers'))),
+    types: defaultEmpty(args.types.map(t => validateBase64String(t.trim(), 'types'))),
     limit: validateInteger(args.limit, 'limit', 10, 1, 10000),
     offset: validatePositiveIntegerOrZero(defaultZero(args.offset), 'offset'),
     privileged: defaultFalse(args.privileged),
-    privilegedReason: validateOptionalStringLength(
-      args.privilegedReason,
-      'privilegedReason',
-      5,
-      50
-    ),
+    privilegedReason: validateOptionalStringLength(args.privilegedReason, 'privilegedReason', 5, 50),
     partial: undefined
   }
   return vargs
@@ -767,18 +626,12 @@ function validateCertificateFields(
   return fields
 }
 
-function validateKeyringRevealer(
-  kr: KeyringRevealer,
-  name: string
-): KeyringRevealer {
+function validateKeyringRevealer(kr: KeyringRevealer, name: string): KeyringRevealer {
   if (kr === 'certifier') return kr
   return validateHexString(kr, name)
 }
 
-function validateOptionalKeyringRevealer(
-  kr: KeyringRevealer | undefined,
-  name: string
-): KeyringRevealer | undefined {
+function validateOptionalKeyringRevealer(kr: KeyringRevealer | undefined, name: string): KeyringRevealer | undefined {
   if (kr === undefined) return undefined
   return validateKeyringRevealer(kr, name)
 }
@@ -814,61 +667,31 @@ export async function validateAcquireCertificateArgs(
   const vargs: ValidAcquireCertificateArgs = {
     acquisitionProtocol: args.acquisitionProtocol,
     type: validateBase64String(args.type, 'type'),
-    serialNumber: validateOptionalBase64String(
-      args.serialNumber,
-      'serialNumber'
-    ),
+    serialNumber: validateOptionalBase64String(args.serialNumber, 'serialNumber'),
     certifier: validateHexString(args.certifier, 'certifier'),
-    revocationOutpoint: validateOptionalOutpointString(
-      args.revocationOutpoint,
-      'revocationOutpoint'
-    ),
+    revocationOutpoint: validateOptionalOutpointString(args.revocationOutpoint, 'revocationOutpoint'),
     fields: validateCertificateFields(args.fields),
     signature: validateOptionalHexString(args.signature, 'signature'),
     certifierUrl: args.certifierUrl,
-    keyringRevealer: validateOptionalKeyringRevealer(
-      args.keyringRevealer,
-      'keyringRevealer'
-    ),
-    keyringForSubject: validateOptionalKeyringForSubject(
-      args.keyringForSubject,
-      'keyringForSubject'
-    ),
+    keyringRevealer: validateOptionalKeyringRevealer(args.keyringRevealer, 'keyringRevealer'),
+    keyringForSubject: validateOptionalKeyringForSubject(args.keyringForSubject, 'keyringForSubject'),
     privileged: defaultFalse(args.privileged),
-    privilegedReason: validateOptionalStringLength(
-      args.privilegedReason,
-      'privilegedReason',
-      5,
-      50
-    )
+    privilegedReason: validateOptionalStringLength(args.privilegedReason, 'privilegedReason', 5, 50)
   }
   if (vargs.privileged && !vargs.privilegedReason)
-    throw new sdk.WERR_INVALID_PARAMETER(
-      'privilegedReason',
-      `valid when 'privileged' is true `
-    )
+    throw new sdk.WERR_INVALID_PARAMETER('privilegedReason', `valid when 'privileged' is true `)
   if (vargs.acquisitionProtocol === 'direct') {
     if (!vargs.serialNumber)
-      throw new sdk.WERR_INVALID_PARAMETER(
-        'serialNumber',
-        'valid when acquisitionProtocol is "direct"'
-      )
+      throw new sdk.WERR_INVALID_PARAMETER('serialNumber', 'valid when acquisitionProtocol is "direct"')
     if (!vargs.signature)
-      throw new sdk.WERR_INVALID_PARAMETER(
-        'signature',
-        'valid when acquisitionProtocol is "direct"'
-      )
+      throw new sdk.WERR_INVALID_PARAMETER('signature', 'valid when acquisitionProtocol is "direct"')
     if (!vargs.revocationOutpoint)
-      throw new sdk.WERR_INVALID_PARAMETER(
-        'revocationOutpoint',
-        'valid when acquisitionProtocol is "direct"'
-      )
+      throw new sdk.WERR_INVALID_PARAMETER('revocationOutpoint', 'valid when acquisitionProtocol is "direct"')
   }
   return vargs
 }
 
-export interface ValidAcquireDirectCertificateArgs
-  extends ValidWalletSignerArgs {
+export interface ValidAcquireDirectCertificateArgs extends ValidWalletSignerArgs {
   type: Base64String
   serialNumber: Base64String
   certifier: PubKeyHex
@@ -889,8 +712,7 @@ export interface ValidAcquireDirectCertificateArgs
   privilegedReason?: DescriptionString5to50Bytes
 }
 
-export interface ValidAcquireIssuanceCertificateArgs
-  extends ValidWalletSignerArgs {
+export interface ValidAcquireIssuanceCertificateArgs extends ValidWalletSignerArgs {
   type: Base64String
   certifier: PubKeyHex
   certifierUrl: string
@@ -910,44 +732,20 @@ export function validateAcquireIssuanceCertificateArgs(
   args: AcquireCertificateArgs
 ): ValidAcquireIssuanceCertificateArgs {
   if (args.acquisitionProtocol !== 'issuance')
-    throw new sdk.WERR_INTERNAL(
-      'Only acquire certificate via issuance requests allowed here.'
-    )
+    throw new sdk.WERR_INTERNAL('Only acquire certificate via issuance requests allowed here.')
   if (args.serialNumber)
-    throw new sdk.WERR_INVALID_PARAMETER(
-      'serialNumber',
-      'valid when acquisitionProtocol is "direct"'
-    )
-  if (args.signature)
-    throw new sdk.WERR_INVALID_PARAMETER(
-      'signature',
-      'valid when acquisitionProtocol is "direct"'
-    )
+    throw new sdk.WERR_INVALID_PARAMETER('serialNumber', 'valid when acquisitionProtocol is "direct"')
+  if (args.signature) throw new sdk.WERR_INVALID_PARAMETER('signature', 'valid when acquisitionProtocol is "direct"')
   if (args.revocationOutpoint)
-    throw new sdk.WERR_INVALID_PARAMETER(
-      'revocationOutpoint',
-      'valid when acquisitionProtocol is "direct"'
-    )
+    throw new sdk.WERR_INVALID_PARAMETER('revocationOutpoint', 'valid when acquisitionProtocol is "direct"')
   if (args.keyringRevealer)
-    throw new sdk.WERR_INVALID_PARAMETER(
-      'keyringRevealer',
-      'valid when acquisitionProtocol is "direct"'
-    )
+    throw new sdk.WERR_INVALID_PARAMETER('keyringRevealer', 'valid when acquisitionProtocol is "direct"')
   if (args.keyringForSubject)
-    throw new sdk.WERR_INVALID_PARAMETER(
-      'keyringForSubject',
-      'valid when acquisitionProtocol is "direct"'
-    )
+    throw new sdk.WERR_INVALID_PARAMETER('keyringForSubject', 'valid when acquisitionProtocol is "direct"')
   if (!args.certifierUrl)
-    throw new sdk.WERR_INVALID_PARAMETER(
-      'certifierUrl',
-      'valid when acquisitionProtocol is "issuance"'
-    )
+    throw new sdk.WERR_INVALID_PARAMETER('certifierUrl', 'valid when acquisitionProtocol is "issuance"')
   if (args.privileged && !args.privilegedReason)
-    throw new sdk.WERR_INVALID_PARAMETER(
-      'privilegedReason',
-      `valid when 'privileged' is true `
-    )
+    throw new sdk.WERR_INVALID_PARAMETER('privilegedReason', `valid when 'privileged' is true `)
 
   const vargs: ValidAcquireIssuanceCertificateArgs = {
     type: validateBase64String(args.type, 'type'),
@@ -955,79 +753,37 @@ export function validateAcquireIssuanceCertificateArgs(
     certifierUrl: args.certifierUrl,
     fields: validateCertificateFields(args.fields),
     privileged: defaultFalse(args.privileged),
-    privilegedReason: validateOptionalStringLength(
-      args.privilegedReason,
-      'privilegedReason',
-      5,
-      50
-    ),
+    privilegedReason: validateOptionalStringLength(args.privilegedReason, 'privilegedReason', 5, 50),
     subject: ''
   }
   return vargs
 }
-export function validateAcquireDirectCertificateArgs(
-  args: AcquireCertificateArgs
-): ValidAcquireDirectCertificateArgs {
+export function validateAcquireDirectCertificateArgs(args: AcquireCertificateArgs): ValidAcquireDirectCertificateArgs {
   if (args.acquisitionProtocol !== 'direct')
-    throw new sdk.WERR_INTERNAL(
-      'Only acquire direct certificate requests allowed here.'
-    )
+    throw new sdk.WERR_INTERNAL('Only acquire direct certificate requests allowed here.')
   if (!args.serialNumber)
-    throw new sdk.WERR_INVALID_PARAMETER(
-      'serialNumber',
-      'valid when acquisitionProtocol is "direct"'
-    )
-  if (!args.signature)
-    throw new sdk.WERR_INVALID_PARAMETER(
-      'signature',
-      'valid when acquisitionProtocol is "direct"'
-    )
+    throw new sdk.WERR_INVALID_PARAMETER('serialNumber', 'valid when acquisitionProtocol is "direct"')
+  if (!args.signature) throw new sdk.WERR_INVALID_PARAMETER('signature', 'valid when acquisitionProtocol is "direct"')
   if (!args.revocationOutpoint)
-    throw new sdk.WERR_INVALID_PARAMETER(
-      'revocationOutpoint',
-      'valid when acquisitionProtocol is "direct"'
-    )
+    throw new sdk.WERR_INVALID_PARAMETER('revocationOutpoint', 'valid when acquisitionProtocol is "direct"')
   if (!args.keyringRevealer)
-    throw new sdk.WERR_INVALID_PARAMETER(
-      'keyringRevealer',
-      'valid when acquisitionProtocol is "direct"'
-    )
+    throw new sdk.WERR_INVALID_PARAMETER('keyringRevealer', 'valid when acquisitionProtocol is "direct"')
   if (!args.keyringForSubject)
-    throw new sdk.WERR_INVALID_PARAMETER(
-      'keyringForSubject',
-      'valid when acquisitionProtocol is "direct"'
-    )
+    throw new sdk.WERR_INVALID_PARAMETER('keyringForSubject', 'valid when acquisitionProtocol is "direct"')
   if (args.privileged && !args.privilegedReason)
-    throw new sdk.WERR_INVALID_PARAMETER(
-      'privilegedReason',
-      `valid when 'privileged' is true `
-    )
+    throw new sdk.WERR_INVALID_PARAMETER('privilegedReason', `valid when 'privileged' is true `)
 
   const vargs: ValidAcquireDirectCertificateArgs = {
     type: validateBase64String(args.type, 'type'),
     serialNumber: validateBase64String(args.serialNumber, 'serialNumber'),
     certifier: validateHexString(args.certifier, 'certifier'),
-    revocationOutpoint: validateOutpointString(
-      args.revocationOutpoint,
-      'revocationOutpoint'
-    ),
+    revocationOutpoint: validateOutpointString(args.revocationOutpoint, 'revocationOutpoint'),
     fields: validateCertificateFields(args.fields),
     signature: validateHexString(args.signature, 'signature'),
-    keyringRevealer: validateKeyringRevealer(
-      args.keyringRevealer,
-      'keyringRevealer'
-    ),
-    keyringForSubject: validateKeyringForSubject(
-      args.keyringForSubject,
-      'keyringForSubject'
-    ),
+    keyringRevealer: validateKeyringRevealer(args.keyringRevealer, 'keyringRevealer'),
+    keyringForSubject: validateKeyringForSubject(args.keyringForSubject, 'keyringForSubject'),
     privileged: defaultFalse(args.privileged),
-    privilegedReason: validateOptionalStringLength(
-      args.privilegedReason,
-      'privilegedReason',
-      5,
-      50
-    ),
+    privilegedReason: validateOptionalStringLength(args.privilegedReason, 'privilegedReason', 5, 50),
     subject: ''
   }
   return vargs
@@ -1047,51 +803,26 @@ export interface ValidProveCertificateArgs extends ValidWalletSignerArgs {
   privilegedReason?: DescriptionString5to50Bytes
 }
 
-export function validateProveCertificateArgs(
-  args: ProveCertificateArgs
-): ValidProveCertificateArgs {
+export function validateProveCertificateArgs(args: ProveCertificateArgs): ValidProveCertificateArgs {
   if (args.privileged && !args.privilegedReason)
-    throw new sdk.WERR_INVALID_PARAMETER(
-      'privilegedReason',
-      `valid when 'privileged' is true `
-    )
+    throw new sdk.WERR_INVALID_PARAMETER('privilegedReason', `valid when 'privileged' is true `)
 
   const vargs: ValidProveCertificateArgs = {
-    type: validateOptionalBase64String(
-      args.certificate.type,
-      'certificate.type'
-    ),
-    serialNumber: validateOptionalBase64String(
-      args.certificate.serialNumber,
-      'certificate.serialNumber'
-    ),
-    certifier: validateOptionalHexString(
-      args.certificate.certifier,
-      'certificate.certifier'
-    ),
-    subject: validateOptionalHexString(
-      args.certificate.subject,
-      'certificate.subject'
-    ),
+    type: validateOptionalBase64String(args.certificate.type, 'certificate.type'),
+    serialNumber: validateOptionalBase64String(args.certificate.serialNumber, 'certificate.serialNumber'),
+    certifier: validateOptionalHexString(args.certificate.certifier, 'certificate.certifier'),
+    subject: validateOptionalHexString(args.certificate.subject, 'certificate.subject'),
     revocationOutpoint: validateOptionalOutpointString(
       args.certificate.revocationOutpoint,
       'certificate.revocationOutpoint'
     ),
-    signature: validateOptionalHexString(
-      args.certificate.signature,
-      'certificate.signature'
-    ),
+    signature: validateOptionalHexString(args.certificate.signature, 'certificate.signature'),
     fieldsToReveal: defaultEmpty(args.fieldsToReveal).map(fieldName =>
       validateStringLength(fieldName, `fieldsToReveal ${fieldName}`, 1, 50)
     ),
     verifier: validateHexString(args.verifier, 'verifier'),
     privileged: defaultFalse(args.privileged),
-    privilegedReason: validateOptionalStringLength(
-      args.privilegedReason,
-      'privilegedReason',
-      5,
-      50
-    )
+    privilegedReason: validateOptionalStringLength(args.privilegedReason, 'privilegedReason', 5, 50)
   }
   return vargs
 }
@@ -1103,9 +834,7 @@ export interface ValidDiscoverByIdentityKeyArgs extends ValidWalletSignerArgs {
   seekPermission: boolean
 }
 
-export function validateDiscoverByIdentityKeyArgs(
-  args: DiscoverByIdentityKeyArgs
-): ValidDiscoverByIdentityKeyArgs {
+export function validateDiscoverByIdentityKeyArgs(args: DiscoverByIdentityKeyArgs): ValidDiscoverByIdentityKeyArgs {
   const vargs: ValidDiscoverByIdentityKeyArgs = {
     identityKey: validateHexString(args.identityKey, 'identityKey', 66, 66),
     limit: validateInteger(args.limit, 'limit', 10, 1, 10000),
@@ -1131,9 +860,7 @@ function validateAttributes(
   return attributes
 }
 
-export function validateDiscoverByAttributesArgs(
-  args: DiscoverByAttributesArgs
-): ValidDiscoverByAttributesArgs {
+export function validateDiscoverByAttributesArgs(args: DiscoverByAttributesArgs): ValidDiscoverByAttributesArgs {
   const vargs: ValidDiscoverByAttributesArgs = {
     attributes: validateAttributes(args.attributes),
     limit: validateInteger(args.limit, 'limit', 10, 1, 10000),
@@ -1171,18 +898,11 @@ export interface ValidListOutputsArgs extends ValidWalletSignerArgs {
  * @param {PositiveIntegerOrZero} [args.offset] - Optional. Number of outputs to skip before starting to return results.
  * @param {BooleanDefaultTrue} [args.seekPermission] — Optional. Whether to seek permission from the user for this operation if required. Default true, will return an error rather than proceed if set to false.
  */
-export function validateListOutputsArgs(
-  args: ListOutputsArgs
-): ValidListOutputsArgs {
+export function validateListOutputsArgs(args: ListOutputsArgs): ValidListOutputsArgs {
   let tagQueryMode: 'any' | 'all'
-  if (args.tagQueryMode === undefined || args.tagQueryMode === 'any')
-    tagQueryMode = 'any'
+  if (args.tagQueryMode === undefined || args.tagQueryMode === 'any') tagQueryMode = 'any'
   else if (args.tagQueryMode === 'all') tagQueryMode = 'all'
-  else
-    throw new sdk.WERR_INVALID_PARAMETER(
-      'tagQueryMode',
-      `undefined, 'any', or 'all'`
-    )
+  else throw new sdk.WERR_INVALID_PARAMETER('tagQueryMode', `undefined, 'any', or 'all'`)
 
   const vargs: ValidListOutputsArgs = {
     basket: validateStringLength(args.basket, 'basket', 1, 300),
@@ -1229,30 +949,19 @@ export interface ValidListActionsArgs extends ValidWalletSignerArgs {
  * @param {PositiveIntegerOrZero} [args.offset] - Optional. Number of transactions to skip before starting to return the results.
  * @param {BooleanDefaultTrue} [args.seekPermission] — Optional. Whether to seek permission from the user for this operation if required. Default true, will return an error rather than proceed if set to false.
  */
-export function validateListActionsArgs(
-  args: ListActionsArgs
-): ValidListActionsArgs {
+export function validateListActionsArgs(args: ListActionsArgs): ValidListActionsArgs {
   let labelQueryMode: 'any' | 'all'
-  if (args.labelQueryMode === undefined || args.labelQueryMode === 'any')
-    labelQueryMode = 'any'
+  if (args.labelQueryMode === undefined || args.labelQueryMode === 'any') labelQueryMode = 'any'
   else if (args.labelQueryMode === 'all') labelQueryMode = 'all'
-  else
-    throw new sdk.WERR_INVALID_PARAMETER(
-      'labelQueryMode',
-      `undefined, 'any', or 'all'`
-    )
+  else throw new sdk.WERR_INVALID_PARAMETER('labelQueryMode', `undefined, 'any', or 'all'`)
 
   const vargs: ValidListActionsArgs = {
     labels: (args.labels || []).map(t => validateLabel(t)),
     labelQueryMode,
     includeLabels: defaultFalse(args.includeLabels),
     includeInputs: defaultFalse(args.includeInputs),
-    includeInputSourceLockingScripts: defaultFalse(
-      args.includeInputSourceLockingScripts
-    ),
-    includeInputUnlockingScripts: defaultFalse(
-      args.includeInputUnlockingScripts
-    ),
+    includeInputSourceLockingScripts: defaultFalse(args.includeInputSourceLockingScripts),
+    includeInputUnlockingScripts: defaultFalse(args.includeInputUnlockingScripts),
     includeOutputs: defaultFalse(args.includeOutputs),
     includeOutputLockingScripts: defaultFalse(args.includeOutputLockingScripts),
     limit: validateInteger(args.limit, 'limit', 10, 1, 10000),