@bsv/sdk 1.3.12 → 1.3.14

package/src/wallet/substrates/WalletWireProcessor.ts

@@ -1,9 +1,8 @@
-import { WalletInterface } from '../Wallet.interfaces.js'
+import { WalletInterface, SecurityLevel } from '../Wallet.interfaces.js'
 import WalletWire from './WalletWire.js'
 import { Utils } from '../../primitives/index.js'
 import calls from './WalletWireCalls.js'
 import Certificate from '../../auth/certificates/Certificate.js'
-import { SecurityLevel } from '../Wallet.interfaces.js'
 
 /**
  * Processes incoming wallet calls received over a wallet wire, with a given wallet.
@@ -38,7 +37,7 @@ export default class WalletWireProcessor implements WalletWire {
 
       // Map call code to call name
       const callName = calls[callCode] // calls is enum
-      if (!callName) {
+      if (callName === undefined || callName === '') {
         // Invalid call code
         throw new Error(`Invalid call code: ${callCode}`)
       }
@@ -52,7 +51,7 @@ export default class WalletWireProcessor implements WalletWire {
       const paramsReader = messageReader // Remaining bytes
 
       switch (callName) {
-        case 'createAction':
+        case 'createAction': {
           // Deserialize parameters from paramsReader
           const args: any = {}
 
@@ -82,7 +81,9 @@ export default class WalletWireProcessor implements WalletWire {
               // unlockingScript / unlockingScriptLength
               const unlockingScriptLength = paramsReader.readVarIntNum()
               if (unlockingScriptLength >= 0) {
-                const unlockingScriptBytes = paramsReader.read(unlockingScriptLength)
+                const unlockingScriptBytes = paramsReader.read(
+                  unlockingScriptLength
+                )
                 input.unlockingScript = Utils.toHex(unlockingScriptBytes)
               } else {
                 input.unlockingScript = undefined
@@ -92,7 +93,9 @@ export default class WalletWireProcessor implements WalletWire {
 
               // inputDescription
               const inputDescriptionLength = paramsReader.readVarIntNum()
-              const inputDescriptionBytes = paramsReader.read(inputDescriptionLength)
+              const inputDescriptionBytes = paramsReader.read(
+                inputDescriptionLength
+              )
               input.inputDescription = Utils.toUTF8(inputDescriptionBytes)
 
               // sequenceNumber
@@ -126,7 +129,9 @@ export default class WalletWireProcessor implements WalletWire {
 
               // outputDescription
               const outputDescriptionLength = paramsReader.readVarIntNum()
-              const outputDescriptionBytes = paramsReader.read(outputDescriptionLength)
+              const outputDescriptionBytes = paramsReader.read(
+                outputDescriptionLength
+              )
               output.outputDescription = Utils.toUTF8(outputDescriptionBytes)
 
               // basket
@@ -141,8 +146,12 @@ export default class WalletWireProcessor implements WalletWire {
               // customInstructions
               const customInstructionsLength = paramsReader.readVarIntNum()
               if (customInstructionsLength >= 0) {
-                const customInstructionsBytes = paramsReader.read(customInstructionsLength)
-                output.customInstructions = Utils.toUTF8(customInstructionsBytes)
+                const customInstructionsBytes = paramsReader.read(
+                  customInstructionsLength
+                )
+                output.customInstructions = Utils.toUTF8(
+                  customInstructionsBytes
+                )
               } else {
                 output.customInstructions = undefined
               }
@@ -215,7 +224,8 @@ export default class WalletWireProcessor implements WalletWire {
             if (acceptDelayedBroadcastFlag === -1) {
               args.options.acceptDelayedBroadcast = undefined
             } else {
-              args.options.acceptDelayedBroadcast = acceptDelayedBroadcastFlag === 1
+              args.options.acceptDelayedBroadcast =
+                acceptDelayedBroadcastFlag === 1
             }
 
             // trustSelf
@@ -292,13 +302,16 @@ export default class WalletWireProcessor implements WalletWire {
           }
 
           // Call the method
-          const createActionResult = await this.wallet.createAction(args, originator)
+          const createActionResult = await this.wallet.createAction(
+            args,
+            originator
+          )
 
           // Serialize the result
           const resultWriter = new Utils.Writer()
 
           // txid
-          if (createActionResult.txid) {
+          if (createActionResult.txid != null && createActionResult.txid !== '') {
             resultWriter.writeInt8(1)
             resultWriter.write(Utils.toArray(createActionResult.txid, 'hex'))
           } else {
@@ -306,7 +319,7 @@ export default class WalletWireProcessor implements WalletWire {
           }
 
           // tx
-          if (createActionResult.tx) {
+          if (createActionResult.tx != null) {
             resultWriter.writeInt8(1)
             resultWriter.writeVarIntNum(createActionResult.tx.length)
             resultWriter.write(createActionResult.tx)
@@ -315,7 +328,7 @@ export default class WalletWireProcessor implements WalletWire {
           }
 
           // noSendChange
-          if (createActionResult.noSendChange) {
+          if (createActionResult.noSendChange != null) {
             resultWriter.writeVarIntNum(createActionResult.noSendChange.length)
             for (const outpoint of createActionResult.noSendChange) {
               resultWriter.write(this.encodeOutpoint(outpoint))
@@ -325,8 +338,10 @@ export default class WalletWireProcessor implements WalletWire {
           }
 
           // sendWithResults
-          if (createActionResult.sendWithResults) {
-            resultWriter.writeVarIntNum(createActionResult.sendWithResults.length)
+          if (createActionResult.sendWithResults != null) {
+            resultWriter.writeVarIntNum(
+              createActionResult.sendWithResults.length
+            )
             for (const result of createActionResult.sendWithResults) {
               resultWriter.write(Utils.toArray(result.txid, 'hex'))
               let statusCode
@@ -340,11 +355,16 @@ export default class WalletWireProcessor implements WalletWire {
           }
 
           // signableTransaction
-          if (createActionResult.signableTransaction) {
+          if (createActionResult.signableTransaction != null) {
             resultWriter.writeInt8(1)
-            resultWriter.writeVarIntNum(createActionResult.signableTransaction.tx.length)
+            resultWriter.writeVarIntNum(
+              createActionResult.signableTransaction.tx.length
+            )
             resultWriter.write(createActionResult.signableTransaction.tx)
-            const referenceBytes = Utils.toArray(createActionResult.signableTransaction.reference, 'base64')
+            const referenceBytes = Utils.toArray(
+              createActionResult.signableTransaction.reference,
+              'base64'
+            )
             resultWriter.writeVarIntNum(referenceBytes.length)
             resultWriter.write(referenceBytes)
           } else {
@@ -356,1557 +376,1667 @@ export default class WalletWireProcessor implements WalletWire {
           responseWriter.writeUInt8(0) // errorByte = 0
           responseWriter.write(resultWriter.toArray())
           return responseWriter.toArray()
+        }
+        case 'signAction': {
+          const args: any = {}
 
-        case 'signAction':
-          {
-            const args: any = {}
-
-            // Deserialize spends
-            const spendCount = paramsReader.readVarIntNum()
-            args.spends = {}
-            for (let i = 0; i < spendCount; i++) {
-              const inputIndex = paramsReader.readVarIntNum()
-              const spend: any = {}
-
-              // unlockingScript
-              const unlockingScriptLength = paramsReader.readVarIntNum()
-              const unlockingScriptBytes = paramsReader.read(unlockingScriptLength)
-              spend.unlockingScript = Utils.toHex(unlockingScriptBytes)
-
-              // sequenceNumber
-              const sequenceNumber = paramsReader.readVarIntNum()
-              if (sequenceNumber >= 0) {
-                spend.sequenceNumber = sequenceNumber
-              } else {
-                spend.sequenceNumber = undefined
-              }
+          // Deserialize spends
+          const spendCount = paramsReader.readVarIntNum()
+          args.spends = {}
+          for (let i = 0; i < spendCount; i++) {
+            const inputIndex = paramsReader.readVarIntNum()
+            const spend: any = {}
+
+            // unlockingScript
+            const unlockingScriptLength = paramsReader.readVarIntNum()
+            const unlockingScriptBytes = paramsReader.read(
+              unlockingScriptLength
+            )
+            spend.unlockingScript = Utils.toHex(unlockingScriptBytes)
 
-              args.spends[inputIndex] = spend
+            // sequenceNumber
+            const sequenceNumber = paramsReader.readVarIntNum()
+            if (sequenceNumber >= 0) {
+              spend.sequenceNumber = sequenceNumber
+            } else {
+              spend.sequenceNumber = undefined
             }
 
-            // Deserialize reference
-            const referenceLength = paramsReader.readVarIntNum()
-            const referenceBytes = paramsReader.read(referenceLength)
-            args.reference = Utils.toBase64(referenceBytes)
-
-            // Deserialize options
-            const optionsPresent = paramsReader.readInt8()
-            if (optionsPresent === 1) {
-              args.options = {}
-
-              // acceptDelayedBroadcast
-              const acceptDelayedBroadcastFlag = paramsReader.readInt8()
-              if (acceptDelayedBroadcastFlag === -1) {
-                args.options.acceptDelayedBroadcast = undefined
-              } else {
-                args.options.acceptDelayedBroadcast = acceptDelayedBroadcastFlag === 1
-              }
+            args.spends[inputIndex] = spend
+          }
 
-              // returnTXIDOnly
-              const returnTXIDOnlyFlag = paramsReader.readInt8()
-              if (returnTXIDOnlyFlag === -1) {
-                args.options.returnTXIDOnly = undefined
-              } else {
-                args.options.returnTXIDOnly = returnTXIDOnlyFlag === 1
-              }
+          // Deserialize reference
+          const referenceLength = paramsReader.readVarIntNum()
+          const referenceBytes = paramsReader.read(referenceLength)
+          args.reference = Utils.toBase64(referenceBytes)
 
-              // noSend
-              const noSendFlag = paramsReader.readInt8()
-              if (noSendFlag === -1) {
-                args.options.noSend = undefined
-              } else {
-                args.options.noSend = noSendFlag === 1
-              }
+          // Deserialize options
+          const optionsPresent = paramsReader.readInt8()
+          if (optionsPresent === 1) {
+            args.options = {}
 
-              // sendWith
-              const sendWithLength = paramsReader.readVarIntNum()
-              if (sendWithLength >= 0) {
-                args.options.sendWith = []
-                for (let i = 0; i < sendWithLength; i++) {
-                  const txidBytes = paramsReader.read(32)
-                  const txid = Utils.toHex(txidBytes)
-                  args.options.sendWith.push(txid)
-                }
-              } else {
-                args.options.sendWith = undefined
-              }
+            // acceptDelayedBroadcast
+            const acceptDelayedBroadcastFlag = paramsReader.readInt8()
+            if (acceptDelayedBroadcastFlag === -1) {
+              args.options.acceptDelayedBroadcast = undefined
             } else {
-              args.options = undefined
+              args.options.acceptDelayedBroadcast =
+                acceptDelayedBroadcastFlag === 1
             }
 
-            // Call the method
-            const signActionResult = await this.wallet.signAction(args, originator)
-
-            // Serialize the result
-            const resultWriter = new Utils.Writer()
-
-            // txid
-            if (signActionResult.txid) {
-              resultWriter.writeInt8(1)
-              resultWriter.write(Utils.toArray(signActionResult.txid, 'hex'))
+            // returnTXIDOnly
+            const returnTXIDOnlyFlag = paramsReader.readInt8()
+            if (returnTXIDOnlyFlag === -1) {
+              args.options.returnTXIDOnly = undefined
             } else {
-              resultWriter.writeInt8(0)
+              args.options.returnTXIDOnly = returnTXIDOnlyFlag === 1
             }
 
-            // tx
-            if (signActionResult.tx) {
-              resultWriter.writeInt8(1)
-              resultWriter.writeVarIntNum(signActionResult.tx.length)
-              resultWriter.write(signActionResult.tx)
+            // noSend
+            const noSendFlag = paramsReader.readInt8()
+            if (noSendFlag === -1) {
+              args.options.noSend = undefined
             } else {
-              resultWriter.writeInt8(0)
+              args.options.noSend = noSendFlag === 1
             }
 
-            // sendWithResults
-            if (signActionResult.sendWithResults) {
-              resultWriter.writeVarIntNum(signActionResult.sendWithResults.length)
-              for (const result of signActionResult.sendWithResults) {
-                resultWriter.write(Utils.toArray(result.txid, 'hex'))
-                let statusCode
-                if (result.status === 'unproven') statusCode = 1
-                else if (result.status === 'sending') statusCode = 2
-                else if (result.status === 'failed') statusCode = 3
-                resultWriter.writeInt8(statusCode)
+            // sendWith
+            const sendWithLength = paramsReader.readVarIntNum()
+            if (sendWithLength >= 0) {
+              args.options.sendWith = []
+              for (let i = 0; i < sendWithLength; i++) {
+                const txidBytes = paramsReader.read(32)
+                const txid = Utils.toHex(txidBytes)
+                args.options.sendWith.push(txid)
               }
             } else {
-              resultWriter.writeVarIntNum(-1)
+              args.options.sendWith = undefined
             }
-
-            // Return success code and result
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            responseWriter.write(resultWriter.toArray())
-            return responseWriter.toArray()
+          } else {
+            args.options = undefined
           }
-        case 'abortAction':
-          {
-            // Deserialize reference
-            const referenceBytes = paramsReader.read()
-            const reference = Utils.toBase64(referenceBytes)
 
-            // Call the method
-            await this.wallet.abortAction({ reference }, originator)
+          // Call the method
+          const signActionResult = await this.wallet.signAction(
+            args,
+            originator
+          )
+
+          // Serialize the result
+          const resultWriter = new Utils.Writer()
 
-            // Return success code and result
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            return responseWriter.toArray()
+          // txid
+          if (signActionResult.txid != null && signActionResult.txid !== '') {
+            resultWriter.writeInt8(1)
+            resultWriter.write(Utils.toArray(signActionResult.txid, 'hex'))
+          } else {
+            resultWriter.writeInt8(0)
           }
-        case 'listActions':
-          {
-            const args: any = {}
 
-            // Deserialize labels
-            const labelsLength = paramsReader.readVarIntNum()
-            args.labels = []
-            for (let i = 0; i < labelsLength; i++) {
-              const labelLength = paramsReader.readVarIntNum()
-              const labelBytes = paramsReader.read(labelLength)
-              args.labels.push(Utils.toUTF8(labelBytes))
-            }
+          // tx
+          if (signActionResult.tx != null) {
+            resultWriter.writeInt8(1)
+            resultWriter.writeVarIntNum(signActionResult.tx.length)
+            resultWriter.write(signActionResult.tx)
+          } else {
+            resultWriter.writeInt8(0)
+          }
 
-            // Deserialize labelQueryMode
-            const labelQueryModeFlag = paramsReader.readInt8()
-            if (labelQueryModeFlag === -1) {
-              args.labelQueryMode = undefined
-            } else if (labelQueryModeFlag === 1) {
-              args.labelQueryMode = 'any'
-            } else if (labelQueryModeFlag === 2) {
-              args.labelQueryMode = 'all'
+          // sendWithResults
+          if (signActionResult.sendWithResults != null) {
+            resultWriter.writeVarIntNum(
+              signActionResult.sendWithResults.length
+            )
+            for (const result of signActionResult.sendWithResults) {
+              resultWriter.write(Utils.toArray(result.txid, 'hex'))
+              let statusCode
+              if (result.status === 'unproven') statusCode = 1
+              else if (result.status === 'sending') statusCode = 2
+              else if (result.status === 'failed') statusCode = 3
+              resultWriter.writeInt8(statusCode)
             }
+          } else {
+            resultWriter.writeVarIntNum(-1)
+          }
 
-            // Deserialize include options
-            const includeOptionsNames = [
-              'includeLabels',
-              'includeInputs',
-              'includeInputSourceLockingScripts',
-              'includeInputUnlockingScripts',
-              'includeOutputs',
-              'includeOutputLockingScripts'
-            ]
-            for (const optionName of includeOptionsNames) {
-              const optionFlag = paramsReader.readInt8()
-              if (optionFlag === -1) {
-                args[optionName] = undefined
-              } else {
-                args[optionName] = optionFlag === 1
-              }
-            }
+          // Return success code and result
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.write(resultWriter.toArray())
+          return responseWriter.toArray()
+        }
+        case 'abortAction': {
+          // Deserialize reference
+          const referenceBytes = paramsReader.read()
+          const reference = Utils.toBase64(referenceBytes)
 
-            // Deserialize limit
-            const limit = paramsReader.readVarIntNum()
-            if (limit >= 0) {
-              args.limit = limit
-            } else {
-              args.limit = undefined
-            }
+          // Call the method
+          await this.wallet.abortAction({ reference }, originator)
 
-            // Deserialize offset
-            const offset = paramsReader.readVarIntNum()
-            if (offset >= 0) {
-              args.offset = offset
-            } else {
-              args.offset = undefined
-            }
+          // Return success code and result
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          return responseWriter.toArray()
+        }
+        case 'listActions': {
+          const args: any = {}
+
+          // Deserialize labels
+          const labelsLength = paramsReader.readVarIntNum()
+          args.labels = []
+          for (let i = 0; i < labelsLength; i++) {
+            const labelLength = paramsReader.readVarIntNum()
+            const labelBytes = paramsReader.read(labelLength)
+            args.labels.push(Utils.toUTF8(labelBytes))
+          }
 
-            // Deserialize seekPermission
-            const seekPermission = paramsReader.readInt8()
-            if (seekPermission >= 0) {
-              args.seekPermission = seekPermission === 1
+          // Deserialize labelQueryMode
+          const labelQueryModeFlag = paramsReader.readInt8()
+          if (labelQueryModeFlag === -1) {
+            args.labelQueryMode = undefined
+          } else if (labelQueryModeFlag === 1) {
+            args.labelQueryMode = 'any'
+          } else if (labelQueryModeFlag === 2) {
+            args.labelQueryMode = 'all'
+          }
+
+          // Deserialize include options
+          const includeOptionsNames = [
+            'includeLabels',
+            'includeInputs',
+            'includeInputSourceLockingScripts',
+            'includeInputUnlockingScripts',
+            'includeOutputs',
+            'includeOutputLockingScripts'
+          ]
+          for (const optionName of includeOptionsNames) {
+            const optionFlag = paramsReader.readInt8()
+            if (optionFlag === -1) {
+              args[optionName] = undefined
             } else {
-              args.seekPermission = undefined
+              args[optionName] = optionFlag === 1
             }
+          }
 
-            // Call the method
-            const listActionsResult = await this.wallet.listActions(args, originator)
+          // Deserialize limit
+          const limit = paramsReader.readVarIntNum()
+          if (limit >= 0) {
+            args.limit = limit
+          } else {
+            args.limit = undefined
+          }
 
-            // Serialize the result
-            const resultWriter = new Utils.Writer()
+          // Deserialize offset
+          const offset = paramsReader.readVarIntNum()
+          if (offset >= 0) {
+            args.offset = offset
+          } else {
+            args.offset = undefined
+          }
 
-            // totalActions
-            resultWriter.writeVarIntNum(listActionsResult.totalActions)
+          // Deserialize seekPermission
+          const seekPermission = paramsReader.readInt8()
+          if (seekPermission >= 0) {
+            args.seekPermission = seekPermission === 1
+          } else {
+            args.seekPermission = undefined
+          }
 
-            // actions
-            for (const action of listActionsResult.actions) {
-              // txid
-              resultWriter.write(Utils.toArray(action.txid, 'hex'))
+          // Call the method
+          const listActionsResult = await this.wallet.listActions(
+            args,
+            originator
+          )
 
-              // satoshis
-              resultWriter.writeVarIntNum(action.satoshis)
+          // Serialize the result
+          const resultWriter = new Utils.Writer()
 
-              // status
-              let statusCode
-              switch (action.status) {
-                case 'completed': statusCode = 1; break
-                case 'unprocessed': statusCode = 2; break
-                case 'sending': statusCode = 3; break
-                case 'unproven': statusCode = 4; break
-                case 'unsigned': statusCode = 5; break
-                case 'nosend': statusCode = 6; break
-                case 'nonfinal': statusCode = 7; break
-                default: statusCode = -1; break
-              }
-              resultWriter.writeInt8(statusCode)
+          // totalActions
+          resultWriter.writeVarIntNum(listActionsResult.totalActions)
 
-              // isOutgoing
-              resultWriter.writeInt8(action.isOutgoing ? 1 : 0)
-
-              // description
-              const descriptionBytes = Utils.toArray(action.description, 'utf8')
-              resultWriter.writeVarIntNum(descriptionBytes.length)
-              resultWriter.write(descriptionBytes)
-
-              // labels
-              if (action.labels !== undefined) {
-                resultWriter.writeVarIntNum(action.labels.length)
-                for (const label of action.labels) {
-                  const labelBytes = Utils.toArray(label, 'utf8')
-                  resultWriter.writeVarIntNum(labelBytes.length)
-                  resultWriter.write(labelBytes)
-                }
-              } else {
-                resultWriter.writeVarIntNum(-1)
+          // actions
+          for (const action of listActionsResult.actions) {
+            // txid
+            resultWriter.write(Utils.toArray(action.txid, 'hex'))
+
+            // satoshis
+            resultWriter.writeVarIntNum(action.satoshis)
+
+            // status
+            let statusCode
+            switch (action.status) {
+              case 'completed':
+                statusCode = 1
+                break
+              case 'unprocessed':
+                statusCode = 2
+                break
+              case 'sending':
+                statusCode = 3
+                break
+              case 'unproven':
+                statusCode = 4
+                break
+              case 'unsigned':
+                statusCode = 5
+                break
+              case 'nosend':
+                statusCode = 6
+                break
+              case 'nonfinal':
+                statusCode = 7
+                break
+              default:
+                statusCode = -1
+                break
+            }
+            resultWriter.writeInt8(statusCode)
+
+            // isOutgoing
+            resultWriter.writeInt8(action.isOutgoing ? 1 : 0)
+
+            // description
+            const descriptionBytes = Utils.toArray(action.description, 'utf8')
+            resultWriter.writeVarIntNum(descriptionBytes.length)
+            resultWriter.write(descriptionBytes)
+
+            // labels
+            if (action.labels !== undefined) {
+              resultWriter.writeVarIntNum(action.labels.length)
+              for (const label of action.labels) {
+                const labelBytes = Utils.toArray(label, 'utf8')
+                resultWriter.writeVarIntNum(labelBytes.length)
+                resultWriter.write(labelBytes)
               }
+            } else {
+              resultWriter.writeVarIntNum(-1)
+            }
 
-              // version
-              resultWriter.writeVarIntNum(action.version)
-
-              // lockTime
-              resultWriter.writeVarIntNum(action.lockTime)
-
-              // inputs
-              if (action.inputs !== undefined) {
-                resultWriter.writeVarIntNum(action.inputs.length)
-                for (const input of action.inputs) {
-                  // sourceOutpoint
-                  resultWriter.write(this.encodeOutpoint(input.sourceOutpoint))
-
-                  // sourceSatoshis
-                  resultWriter.writeVarIntNum(input.sourceSatoshis)
-
-                  // sourceLockingScript
-                  if (input.sourceLockingScript !== undefined) {
-                    const sourceLockingScriptBytes = Utils.toArray(input.sourceLockingScript, 'hex')
-                    resultWriter.writeVarIntNum(sourceLockingScriptBytes.length)
-                    resultWriter.write(sourceLockingScriptBytes)
-                  } else {
-                    resultWriter.writeVarIntNum(-1)
-                  }
+            // version
+            resultWriter.writeVarIntNum(action.version)
 
-                  // unlockingScript
-                  if (input.unlockingScript !== undefined) {
-                    const unlockingScriptBytes = Utils.toArray(input.unlockingScript, 'hex')
-                    resultWriter.writeVarIntNum(unlockingScriptBytes.length)
-                    resultWriter.write(unlockingScriptBytes)
-                  } else {
-                    resultWriter.writeVarIntNum(-1)
-                  }
+            // lockTime
+            resultWriter.writeVarIntNum(action.lockTime)
 
-                  // inputDescription
-                  const inputDescriptionBytes = Utils.toArray(input.inputDescription, 'utf8')
-                  resultWriter.writeVarIntNum(inputDescriptionBytes.length)
-                  resultWriter.write(inputDescriptionBytes)
+            // inputs
+            if (action.inputs !== undefined) {
+              resultWriter.writeVarIntNum(action.inputs.length)
+              for (const input of action.inputs) {
+                // sourceOutpoint
+                resultWriter.write(this.encodeOutpoint(input.sourceOutpoint))
 
-                  // sequenceNumber
-                  resultWriter.writeVarIntNum(input.sequenceNumber)
-                }
-              } else {
-                resultWriter.writeVarIntNum(-1)
-              }
+                // sourceSatoshis
+                resultWriter.writeVarIntNum(input.sourceSatoshis)
 
-              // outputs
-              if (action.outputs !== undefined) {
-                resultWriter.writeVarIntNum(action.outputs.length)
-                for (const output of action.outputs) {
-                  // outputIndex
-                  resultWriter.writeVarIntNum(output.outputIndex)
-
-                  // satoshis
-                  resultWriter.writeVarIntNum(output.satoshis)
-
-                  // lockingScript
-                  if (output.lockingScript !== undefined) {
-                    const lockingScriptBytes = Utils.toArray(output.lockingScript, 'hex')
-                    resultWriter.writeVarIntNum(lockingScriptBytes.length)
-                    resultWriter.write(lockingScriptBytes)
-                  } else {
-                    resultWriter.writeVarIntNum(-1)
-                  }
+                // sourceLockingScript
+                if (input.sourceLockingScript !== undefined) {
+                  const sourceLockingScriptBytes = Utils.toArray(
+                    input.sourceLockingScript,
+                    'hex'
+                  )
+                  resultWriter.writeVarIntNum(sourceLockingScriptBytes.length)
+                  resultWriter.write(sourceLockingScriptBytes)
+                } else {
+                  resultWriter.writeVarIntNum(-1)
+                }
 
-                  // spendable
-                  resultWriter.writeInt8(output.spendable ? 1 : 0)
-
-                  // outputDescription
-                  const outputDescriptionBytes = Utils.toArray(output.outputDescription, 'utf8')
-                  resultWriter.writeVarIntNum(outputDescriptionBytes.length)
-                  resultWriter.write(outputDescriptionBytes)
-
-                  // basket
-                  if (output.basket !== undefined) {
-                    const basketBytes = Utils.toArray(output.basket, 'utf8')
-                    resultWriter.writeVarIntNum(basketBytes.length)
-                    resultWriter.write(basketBytes)
-                  } else {
-                    resultWriter.writeVarIntNum(-1)
-                  }
+                // unlockingScript
+                if (input.unlockingScript !== undefined) {
+                  const unlockingScriptBytes = Utils.toArray(
+                    input.unlockingScript,
+                    'hex'
+                  )
+                  resultWriter.writeVarIntNum(unlockingScriptBytes.length)
+                  resultWriter.write(unlockingScriptBytes)
+                } else {
+                  resultWriter.writeVarIntNum(-1)
+                }
 
-                  // tags
-                  if (output.tags !== undefined) {
-                    resultWriter.writeVarIntNum(output.tags.length)
-                    for (const tag of output.tags) {
-                      const tagBytes = Utils.toArray(tag, 'utf8')
-                      resultWriter.writeVarIntNum(tagBytes.length)
-                      resultWriter.write(tagBytes)
-                    }
-                  } else {
-                    resultWriter.writeVarIntNum(-1)
-                  }
+                // inputDescription
+                const inputDescriptionBytes = Utils.toArray(
+                  input.inputDescription,
+                  'utf8'
+                )
+                resultWriter.writeVarIntNum(inputDescriptionBytes.length)
+                resultWriter.write(inputDescriptionBytes)
 
-                  // customInstructions
-                  if (output.customInstructions !== undefined) {
-                    const customInstructionsBytes = Utils.toArray(output.customInstructions, 'utf8')
-                    resultWriter.writeVarIntNum(customInstructionsBytes.length)
-                    resultWriter.write(customInstructionsBytes)
-                  } else {
-                    resultWriter.writeVarIntNum(-1)
-                  }
-                }
-              } else {
-                resultWriter.writeVarIntNum(-1)
+                // sequenceNumber
+                resultWriter.writeVarIntNum(input.sequenceNumber)
               }
+            } else {
+              resultWriter.writeVarIntNum(-1)
             }
 
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            responseWriter.write(resultWriter.toArray())
-            return responseWriter.toArray()
-          }
-        case 'internalizeAction':
-          {
-            const args: any = {}
-
-            // Read tx
-            const txLength = paramsReader.readVarIntNum()
-            args.tx = paramsReader.read(txLength)
-
-            // Read outputs
-            const outputsLength = paramsReader.readVarIntNum()
-            args.outputs = []
-            for (let i = 0; i < outputsLength; i++) {
-              const output: any = {}
-
-              // outputIndex
-              output.outputIndex = paramsReader.readVarIntNum()
-
-              // protocol
-              const protocolFlag = paramsReader.readUInt8()
-              if (protocolFlag === 1) {
-                output.protocol = 'wallet payment'
-                output.paymentRemittance = {}
-
-                // senderIdentityKey
-                const senderIdentityKeyBytes = paramsReader.read(33)
-                output.paymentRemittance.senderIdentityKey = Utils.toHex(senderIdentityKeyBytes)
+            // outputs
+            if (action.outputs !== undefined) {
+              resultWriter.writeVarIntNum(action.outputs.length)
+              for (const output of action.outputs) {
+                // outputIndex
+                resultWriter.writeVarIntNum(output.outputIndex)
+
+                // satoshis
+                resultWriter.writeVarIntNum(output.satoshis)
+
+                // lockingScript
+                if (output.lockingScript !== undefined) {
+                  const lockingScriptBytes = Utils.toArray(
+                    output.lockingScript,
+                    'hex'
+                  )
+                  resultWriter.writeVarIntNum(lockingScriptBytes.length)
+                  resultWriter.write(lockingScriptBytes)
+                } else {
+                  resultWriter.writeVarIntNum(-1)
+                }
 
-                // derivationPrefix
-                const derivationPrefixLength = paramsReader.readVarIntNum()
-                const derivationPrefixBytes = paramsReader.read(derivationPrefixLength)
-                output.paymentRemittance.derivationPrefix = Utils.toBase64(derivationPrefixBytes)
+                // spendable
+                resultWriter.writeInt8(output.spendable ? 1 : 0)
 
-                // derivationSuffix
-                const derivationSuffixLength = paramsReader.readVarIntNum()
-                const derivationSuffixBytes = paramsReader.read(derivationSuffixLength)
-                output.paymentRemittance.derivationSuffix = Utils.toBase64(derivationSuffixBytes)
-              } else if (protocolFlag === 2) {
-                output.protocol = 'basket insertion'
-                output.insertionRemittance = {}
+                // outputDescription
+                const outputDescriptionBytes = Utils.toArray(
+                  output.outputDescription,
+                  'utf8'
+                )
+                resultWriter.writeVarIntNum(outputDescriptionBytes.length)
+                resultWriter.write(outputDescriptionBytes)
 
                 // basket
-                const basketLength = paramsReader.readVarIntNum()
-                const basketBytes = paramsReader.read(basketLength)
-                output.insertionRemittance.basket = Utils.toUTF8(basketBytes)
-
-                // customInstructions
-                const customInstructionsLength = paramsReader.readVarIntNum()
-                if (customInstructionsLength >= 0) {
-                  const customInstructionsBytes = paramsReader.read(customInstructionsLength)
-                  output.insertionRemittance.customInstructions = Utils.toUTF8(customInstructionsBytes)
+                if (output.basket !== undefined) {
+                  const basketBytes = Utils.toArray(output.basket, 'utf8')
+                  resultWriter.writeVarIntNum(basketBytes.length)
+                  resultWriter.write(basketBytes)
+                } else {
+                  resultWriter.writeVarIntNum(-1)
                 }
 
                 // tags
-                const tagsLength = paramsReader.readVarIntNum()
-                if (tagsLength > 0) {
-                  output.insertionRemittance.tags = []
-                  for (let j = 0; j < tagsLength; j++) {
-                    const tagLength = paramsReader.readVarIntNum()
-                    const tagBytes = paramsReader.read(tagLength)
-                    output.insertionRemittance.tags.push(Utils.toUTF8(tagBytes))
+                if (output.tags !== undefined) {
+                  resultWriter.writeVarIntNum(output.tags.length)
+                  for (const tag of output.tags) {
+                    const tagBytes = Utils.toArray(tag, 'utf8')
+                    resultWriter.writeVarIntNum(tagBytes.length)
+                    resultWriter.write(tagBytes)
                   }
                 } else {
-                  output.insertionRemittance.tags = []
+                  resultWriter.writeVarIntNum(-1)
                 }
-              }
 
-              args.outputs.push(output)
-            }
-
-            const numberOfLabels = paramsReader.readVarIntNum()
-            if (numberOfLabels >= 0) {
-              args.labels = []
-              for (let i = 0; i < numberOfLabels; i++) {
-                const labelLength = paramsReader.readVarIntNum()
-                args.labels.push(Utils.toUTF8(paramsReader.read(labelLength)))
+                // customInstructions
+                if (output.customInstructions !== undefined) {
+                  const customInstructionsBytes = Utils.toArray(
+                    output.customInstructions,
+                    'utf8'
+                  )
+                  resultWriter.writeVarIntNum(customInstructionsBytes.length)
+                  resultWriter.write(customInstructionsBytes)
+                } else {
+                  resultWriter.writeVarIntNum(-1)
+                }
               }
+            } else {
+              resultWriter.writeVarIntNum(-1)
             }
+          }
 
-            const descriptionLength = paramsReader.readVarIntNum()
-            args.description = Utils.toUTF8(paramsReader.read(descriptionLength))
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.write(resultWriter.toArray())
+          return responseWriter.toArray()
+        }
+        case 'internalizeAction': {
+          const args: any = {}
 
-            // Deserialize seekPermission
-            const seekPermission = paramsReader.readInt8()
-            if (seekPermission >= 0) {
-              args.seekPermission = seekPermission === 1
-            } else {
-              args.seekPermission = undefined
-            }
+          // Read tx
+          const txLength = paramsReader.readVarIntNum()
+          args.tx = paramsReader.read(txLength)
 
-            // Call the method
-            await this.wallet.internalizeAction(args, originator)
+          // Read outputs
+          const outputsLength = paramsReader.readVarIntNum()
+          args.outputs = []
+          for (let i = 0; i < outputsLength; i++) {
+            const output: any = {}
+
+            // outputIndex
+            output.outputIndex = paramsReader.readVarIntNum()
+
+            // protocol
+            const protocolFlag = paramsReader.readUInt8()
+            if (protocolFlag === 1) {
+              output.protocol = 'wallet payment'
+              output.paymentRemittance = {}
+
+              // senderIdentityKey
+              const senderIdentityKeyBytes = paramsReader.read(33)
+              output.paymentRemittance.senderIdentityKey = Utils.toHex(
+                senderIdentityKeyBytes
+              )
 
-            // Return success code and result
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            return responseWriter.toArray()
-          }
+              // derivationPrefix
+              const derivationPrefixLength = paramsReader.readVarIntNum()
+              const derivationPrefixBytes = paramsReader.read(
+                derivationPrefixLength
+              )
+              output.paymentRemittance.derivationPrefix = Utils.toBase64(
+                derivationPrefixBytes
+              )
 
-        case 'listOutputs':
-          {
-            const args: any = {}
+              // derivationSuffix
+              const derivationSuffixLength = paramsReader.readVarIntNum()
+              const derivationSuffixBytes = paramsReader.read(
+                derivationSuffixLength
+              )
+              output.paymentRemittance.derivationSuffix = Utils.toBase64(
+                derivationSuffixBytes
+              )
+            } else if (protocolFlag === 2) {
+              output.protocol = 'basket insertion'
+              output.insertionRemittance = {}
 
-            // Deserialize basket
-            const basketLength = paramsReader.readVarIntNum()
-            const basketBytes = paramsReader.read(basketLength)
-            args.basket = Utils.toUTF8(basketBytes)
+              // basket
+              const basketLength = paramsReader.readVarIntNum()
+              const basketBytes = paramsReader.read(basketLength)
+              output.insertionRemittance.basket = Utils.toUTF8(basketBytes)
 
-            // Deserialize tags
-            const tagsLength = paramsReader.readVarIntNum()
-            if (tagsLength > 0) {
-              args.tags = []
-              for (let i = 0; i < tagsLength; i++) {
-                const tagLength = paramsReader.readVarIntNum()
-                const tagBytes = paramsReader.read(tagLength)
-                args.tags.push(Utils.toUTF8(tagBytes))
+              // customInstructions
+              const customInstructionsLength = paramsReader.readVarIntNum()
+              if (customInstructionsLength >= 0) {
+                const customInstructionsBytes = paramsReader.read(
+                  customInstructionsLength
+                )
+                output.insertionRemittance.customInstructions = Utils.toUTF8(
+                  customInstructionsBytes
+                )
               }
-            } else {
-              args.tags = undefined
-            }
 
-            // Deserialize tagQueryMode
-            const tagQueryModeFlag = paramsReader.readInt8()
-            if (tagQueryModeFlag === 1) {
-              args.tagQueryMode = 'all'
-            } else if (tagQueryModeFlag === 2) {
-              args.tagQueryMode = 'any'
-            } else {
-              args.tagQueryMode = undefined
+              // tags
+              const tagsLength = paramsReader.readVarIntNum()
+              if (tagsLength > 0) {
+                output.insertionRemittance.tags = []
+                for (let j = 0; j < tagsLength; j++) {
+                  const tagLength = paramsReader.readVarIntNum()
+                  const tagBytes = paramsReader.read(tagLength)
+                  output.insertionRemittance.tags.push(Utils.toUTF8(tagBytes))
+                }
+              } else {
+                output.insertionRemittance.tags = []
+              }
             }
 
-            // Deserialize include
-            const includeFlag = paramsReader.readInt8()
-            if (includeFlag === 1) {
-              args.include = 'locking scripts'
-            } else if (includeFlag === 2) {
-              args.include = 'entire transactions'
-            } else {
-              args.include = undefined
-            }
+            args.outputs.push(output)
+          }
 
-            // Deserialize includeCustomInstructions
-            const includeCustomInstructionsFlag = paramsReader.readInt8()
-            if (includeCustomInstructionsFlag === -1) {
-              args.includeCustomInstructions = undefined
-            } else {
-              args.includeCustomInstructions = includeCustomInstructionsFlag === 1
+          const numberOfLabels = paramsReader.readVarIntNum()
+          if (numberOfLabels >= 0) {
+            args.labels = []
+            for (let i = 0; i < numberOfLabels; i++) {
+              const labelLength = paramsReader.readVarIntNum()
+              args.labels.push(Utils.toUTF8(paramsReader.read(labelLength)))
             }
+          }
 
-            // Deserialize includeTags
-            const includeTagsFlag = paramsReader.readInt8()
-            if (includeTagsFlag === -1) {
-              args.includeTags = undefined
-            } else {
-              args.includeTags = includeTagsFlag === 1
-            }
+          const descriptionLength = paramsReader.readVarIntNum()
+          args.description = Utils.toUTF8(paramsReader.read(descriptionLength))
 
-            // Deserialize includeLabels
-            const includeLabelsFlag = paramsReader.readInt8()
-            if (includeLabelsFlag === -1) {
-              args.includeLabels = undefined
-            } else {
-              args.includeLabels = includeLabelsFlag === 1
-            }
+          // Deserialize seekPermission
+          const seekPermission = paramsReader.readInt8()
+          if (seekPermission >= 0) {
+            args.seekPermission = seekPermission === 1
+          } else {
+            args.seekPermission = undefined
+          }
 
-            // Deserialize limit
-            const limit = paramsReader.readVarIntNum()
-            if (limit >= 0) {
-              args.limit = limit
-            } else {
-              args.limit = undefined
-            }
+          // Call the method
+          await this.wallet.internalizeAction(args, originator)
 
-            // Deserialize offset
-            const offset = paramsReader.readVarIntNum()
-            if (offset >= 0) {
-              args.offset = offset
-            } else {
-              args.offset = undefined
-            }
+          // Return success code and result
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          return responseWriter.toArray()
+        }
 
-            // Deserialize seekPermission
-            const seekPermission = paramsReader.readInt8()
-            if (seekPermission >= 0) {
-              args.seekPermission = seekPermission === 1
-            } else {
-              args.seekPermission = undefined
-            }
+        case 'listOutputs': {
+          const args: any = {}
 
-            // Call the method
-            const listOutputsResult = await this.wallet.listOutputs(args, originator)
+          // Deserialize basket
+          const basketLength = paramsReader.readVarIntNum()
+          const basketBytes = paramsReader.read(basketLength)
+          args.basket = Utils.toUTF8(basketBytes)
 
-            // Serialize the result
-            const resultWriter = new Utils.Writer()
+          // Deserialize tags
+          const tagsLength = paramsReader.readVarIntNum()
+          if (tagsLength > 0) {
+            args.tags = []
+            for (let i = 0; i < tagsLength; i++) {
+              const tagLength = paramsReader.readVarIntNum()
+              const tagBytes = paramsReader.read(tagLength)
+              args.tags.push(Utils.toUTF8(tagBytes))
+            }
+          } else {
+            args.tags = undefined
+          }
 
-            // totalOutputs
-            resultWriter.writeVarIntNum(listOutputsResult.totalOutputs)
+          // Deserialize tagQueryMode
+          const tagQueryModeFlag = paramsReader.readInt8()
+          if (tagQueryModeFlag === 1) {
+            args.tagQueryMode = 'all'
+          } else if (tagQueryModeFlag === 2) {
+            args.tagQueryMode = 'any'
+          } else {
+            args.tagQueryMode = undefined
+          }
 
-            // BEEF length and BEEF or -1
-            if (listOutputsResult.BEEF) {
-              resultWriter.writeVarIntNum(listOutputsResult.BEEF.length)
-              resultWriter.write(listOutputsResult.BEEF)
-            } else {
-              resultWriter.writeVarIntNum(-1)
-            }
+          // Deserialize include
+          const includeFlag = paramsReader.readInt8()
+          if (includeFlag === 1) {
+            args.include = 'locking scripts'
+          } else if (includeFlag === 2) {
+            args.include = 'entire transactions'
+          } else {
+            args.include = undefined
+          }
 
-            // outputs
-            for (const output of listOutputsResult.outputs) {
-              // outpoint
-              resultWriter.write(this.encodeOutpoint(output.outpoint))
+          // Deserialize includeCustomInstructions
+          const includeCustomInstructionsFlag = paramsReader.readInt8()
+          if (includeCustomInstructionsFlag === -1) {
+            args.includeCustomInstructions = undefined
+          } else {
+            args.includeCustomInstructions =
+              includeCustomInstructionsFlag === 1
+          }
 
-              // satoshis
-              resultWriter.writeVarIntNum(output.satoshis)
+          // Deserialize includeTags
+          const includeTagsFlag = paramsReader.readInt8()
+          if (includeTagsFlag === -1) {
+            args.includeTags = undefined
+          } else {
+            args.includeTags = includeTagsFlag === 1
+          }
 
-              // lockingScript
-              if (output.lockingScript !== undefined) {
-                const lockingScriptBytes = Utils.toArray(output.lockingScript, 'hex')
-                resultWriter.writeVarIntNum(lockingScriptBytes.length)
-                resultWriter.write(lockingScriptBytes)
-              } else {
-                resultWriter.writeVarIntNum(-1)
-              }
+          // Deserialize includeLabels
+          const includeLabelsFlag = paramsReader.readInt8()
+          if (includeLabelsFlag === -1) {
+            args.includeLabels = undefined
+          } else {
+            args.includeLabels = includeLabelsFlag === 1
+          }
 
-              // customInstructions
-              if (output.customInstructions !== undefined) {
-                const customInstructionsBytes = Utils.toArray(output.customInstructions, 'utf8')
-                resultWriter.writeVarIntNum(customInstructionsBytes.length)
-                resultWriter.write(customInstructionsBytes)
-              } else {
-                resultWriter.writeVarIntNum(-1)
-              }
-
-              // tags
-              if (output.tags !== undefined) {
-                resultWriter.writeVarIntNum(output.tags.length)
-                for (const tag of output.tags) {
-                  const tagBytes = Utils.toArray(tag, 'utf8')
-                  resultWriter.writeVarIntNum(tagBytes.length)
-                  resultWriter.write(tagBytes)
-                }
-              } else {
-                resultWriter.writeVarIntNum(-1)
-              }
-
-              // labels
-              if (output.labels !== undefined) {
-                resultWriter.writeVarIntNum(output.labels.length)
-                for (const label of output.labels) {
-                  const labelBytes = Utils.toArray(label, 'utf8')
-                  resultWriter.writeVarIntNum(labelBytes.length)
-                  resultWriter.write(labelBytes)
-                }
-              } else {
-                resultWriter.writeVarIntNum(-1)
-              }
-            }
+          // Deserialize limit
+          const limit = paramsReader.readVarIntNum()
+          if (limit >= 0) {
+            args.limit = limit
+          } else {
+            args.limit = undefined
+          }
 
-            // Return success code and result
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            responseWriter.write(resultWriter.toArray())
-            return responseWriter.toArray()
+          // Deserialize offset
+          const offset = paramsReader.readVarIntNum()
+          if (offset >= 0) {
+            args.offset = offset
+          } else {
+            args.offset = undefined
           }
 
-        case 'relinquishOutput':
-          {
-            const args: any = {}
+          // Deserialize seekPermission
+          const seekPermission = paramsReader.readInt8()
+          if (seekPermission >= 0) {
+            args.seekPermission = seekPermission === 1
+          } else {
+            args.seekPermission = undefined
+          }
 
-            // Deserialize basket
-            const basketLength = paramsReader.readVarIntNum()
-            const basketBytes = paramsReader.read(basketLength)
-            args.basket = Utils.toUTF8(basketBytes)
+          // Call the method
+          const listOutputsResult = await this.wallet.listOutputs(
+            args,
+            originator
+          )
 
-            // Deserialize outpoint
-            args.output = this.decodeOutpoint(paramsReader)
+          // Serialize the result
+          const resultWriter = new Utils.Writer()
 
-            // Call the method
-            await this.wallet.relinquishOutput(args, originator)
+          // totalOutputs
+          resultWriter.writeVarIntNum(listOutputsResult.totalOutputs)
 
-            // Return success code and result
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            return responseWriter.toArray()
+          // BEEF length and BEEF or -1
+          if (listOutputsResult.BEEF != null) {
+            resultWriter.writeVarIntNum(listOutputsResult.BEEF.length)
+            resultWriter.write(listOutputsResult.BEEF)
+          } else {
+            resultWriter.writeVarIntNum(-1)
           }
 
-        case 'getPublicKey':
-          {
-            const args: any = {}
-
-            // Deserialize identityKey flag
-            const identityKeyFlag = paramsReader.readUInt8()
-            args.identityKey = identityKeyFlag === 1
+          // outputs
+          for (const output of listOutputsResult.outputs) {
+            // outpoint
+            resultWriter.write(this.encodeOutpoint(output.outpoint))
 
-            if (!args.identityKey) {
-              // Deserialize protocolID
-              args.protocolID = this.decodeProtocolID(paramsReader)
+            // satoshis
+            resultWriter.writeVarIntNum(output.satoshis)
 
-              // Deserialize keyID
-              args.keyID = this.decodeString(paramsReader)
-
-              // Deserialize counterparty
-              args.counterparty = this.decodeCounterparty(paramsReader)
-
-              // Deserialize privilege parameters
-              const privilegedFlag = paramsReader.readInt8()
-              if (privilegedFlag === -1) {
-                args.privileged = undefined
-              } else {
-                args.privileged = privilegedFlag === 1
-              }
-
-              const privilegedReasonLength = paramsReader.readInt8()
-              if (privilegedReasonLength !== -1) {
-                const privilegedReasonBytes = paramsReader.read(privilegedReasonLength)
-                args.privilegedReason = Utils.toUTF8(privilegedReasonBytes)
-              } else {
-                args.privilegedReason = undefined
-              }
+            // lockingScript
+            if (output.lockingScript !== undefined) {
+              const lockingScriptBytes = Utils.toArray(
+                output.lockingScript,
+                'hex'
+              )
+              resultWriter.writeVarIntNum(lockingScriptBytes.length)
+              resultWriter.write(lockingScriptBytes)
+            } else {
+              resultWriter.writeVarIntNum(-1)
+            }
 
-              // Deserialize forSelf
-              const forSelfFlag = paramsReader.readInt8()
-              if (forSelfFlag === -1) {
-                args.forSelf = undefined
-              } else {
-                args.forSelf = forSelfFlag === 1
-              }
+            // customInstructions
+            if (output.customInstructions !== undefined) {
+              const customInstructionsBytes = Utils.toArray(
+                output.customInstructions,
+                'utf8'
+              )
+              resultWriter.writeVarIntNum(customInstructionsBytes.length)
+              resultWriter.write(customInstructionsBytes)
             } else {
-              // Deserialize privilege parameters
-              const privilegedFlag = paramsReader.readInt8()
-              if (privilegedFlag === -1) {
-                args.privileged = undefined
-              } else {
-                args.privileged = privilegedFlag === 1
-              }
+              resultWriter.writeVarIntNum(-1)
+            }
 
-              const privilegedReasonLength = paramsReader.readInt8()
-              if (privilegedReasonLength !== -1) {
-                const privilegedReasonBytes = paramsReader.read(privilegedReasonLength)
-                args.privilegedReason = Utils.toUTF8(privilegedReasonBytes)
-              } else {
-                args.privilegedReason = undefined
+            // tags
+            if (output.tags !== undefined) {
+              resultWriter.writeVarIntNum(output.tags.length)
+              for (const tag of output.tags) {
+                const tagBytes = Utils.toArray(tag, 'utf8')
+                resultWriter.writeVarIntNum(tagBytes.length)
+                resultWriter.write(tagBytes)
               }
+            } else {
+              resultWriter.writeVarIntNum(-1)
             }
 
-            // Deserialize seekPermission
-            const seekPermission = paramsReader.readInt8()
-            if (seekPermission >= 0) {
-              args.seekPermission = seekPermission === 1
+            // labels
+            if (output.labels !== undefined) {
+              resultWriter.writeVarIntNum(output.labels.length)
+              for (const label of output.labels) {
+                const labelBytes = Utils.toArray(label, 'utf8')
+                resultWriter.writeVarIntNum(labelBytes.length)
+                resultWriter.write(labelBytes)
+              }
             } else {
-              args.seekPermission = undefined
+              resultWriter.writeVarIntNum(-1)
             }
+          }
 
-            // Call the method
-            const getPublicKeyResult = await this.wallet.getPublicKey(args, originator)
+          // Return success code and result
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.write(resultWriter.toArray())
+          return responseWriter.toArray()
+        }
 
-            // Serialize the result
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            const publicKeyBytes = Utils.toArray(getPublicKeyResult.publicKey, 'hex')
-            responseWriter.write(publicKeyBytes)
-            return responseWriter.toArray()
-          }
+        case 'relinquishOutput': {
+          const args: any = {}
 
-        case 'encrypt':
-          {
-            const args: any = this.decodeKeyRelatedParams(paramsReader)
+          // Deserialize basket
+          const basketLength = paramsReader.readVarIntNum()
+          const basketBytes = paramsReader.read(basketLength)
+          args.basket = Utils.toUTF8(basketBytes)
 
-            // Deserialize plaintext
-            const plaintextLength = paramsReader.readVarIntNum()
-            args.plaintext = paramsReader.read(plaintextLength)
+          // Deserialize outpoint
+          args.output = this.decodeOutpoint(paramsReader)
 
-            // Deserialize seekPermission
-            const seekPermission = paramsReader.readInt8()
-            if (seekPermission >= 0) {
-              args.seekPermission = seekPermission === 1
-            } else {
-              args.seekPermission = undefined
-            }
+          // Call the method
+          await this.wallet.relinquishOutput(args, originator)
 
-            // Call the method
-            const encryptResult = await this.wallet.encrypt(args, originator)
+          // Return success code and result
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          return responseWriter.toArray()
+        }
 
-            // Serialize the result
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            responseWriter.write(encryptResult.ciphertext)
-            return responseWriter.toArray()
-          }
+        case 'getPublicKey': {
+          const args: any = {}
+
+          // Deserialize identityKey flag
+          const identityKeyFlag = paramsReader.readUInt8()
+          args.identityKey = identityKeyFlag === 1
+
+          if (args.identityKey !== true) {
+            // Deserialize protocolID
+            args.protocolID = this.decodeProtocolID(paramsReader)
 
-        case 'decrypt':
-          {
-            const args: any = this.decodeKeyRelatedParams(paramsReader)
+            // Deserialize keyID
+            args.keyID = this.decodeString(paramsReader)
 
-            // Deserialize ciphertext
-            const ciphertextLength = paramsReader.readVarIntNum()
-            args.ciphertext = paramsReader.read(ciphertextLength)
+            // Deserialize counterparty
+            args.counterparty = this.decodeCounterparty(paramsReader)
 
-            // Deserialize seekPermission
-            const seekPermission = paramsReader.readInt8()
-            if (seekPermission >= 0) {
-              args.seekPermission = seekPermission === 1
+            // Deserialize privilege parameters
+            const privilegedFlag = paramsReader.readInt8()
+            if (privilegedFlag === -1) {
+              args.privileged = undefined
             } else {
-              args.seekPermission = undefined
+              args.privileged = privilegedFlag === 1
             }
 
-            // Call the method
-            const decryptResult = await this.wallet.decrypt(args, originator)
+            const privilegedReasonLength = paramsReader.readInt8()
+            if (privilegedReasonLength !== -1) {
+              const privilegedReasonBytes = paramsReader.read(
+                privilegedReasonLength
+              )
+              args.privilegedReason = Utils.toUTF8(privilegedReasonBytes)
+            } else {
+              args.privilegedReason = undefined
+            }
+
+            // Deserialize forSelf
+            const forSelfFlag = paramsReader.readInt8()
+            if (forSelfFlag === -1) {
+              args.forSelf = undefined
+            } else {
+              args.forSelf = forSelfFlag === 1
+            }
+          } else {
+            // Deserialize privilege parameters
+            const privilegedFlag = paramsReader.readInt8()
+            if (privilegedFlag === -1) {
+              args.privileged = undefined
+            } else {
+              args.privileged = privilegedFlag === 1
+            }
 
-            // Serialize the result
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            responseWriter.write(decryptResult.plaintext)
-            return responseWriter.toArray()
+            const privilegedReasonLength = paramsReader.readInt8()
+            if (privilegedReasonLength !== -1) {
+              const privilegedReasonBytes = paramsReader.read(
+                privilegedReasonLength
+              )
+              args.privilegedReason = Utils.toUTF8(privilegedReasonBytes)
+            } else {
+              args.privilegedReason = undefined
+            }
           }
 
-        case 'createHmac':
-          {
-            const args: any = this.decodeKeyRelatedParams(paramsReader)
+          // Deserialize seekPermission
+          const seekPermission = paramsReader.readInt8()
+          if (seekPermission >= 0) {
+            args.seekPermission = seekPermission === 1
+          } else {
+            args.seekPermission = undefined
+          }
 
-            // Deserialize data
-            const dataLength = paramsReader.readVarIntNum()
-            args.data = paramsReader.read(dataLength)
+          // Call the method
+          const getPublicKeyResult = await this.wallet.getPublicKey(
+            args,
+            originator
+          )
 
-            // Deserialize seekPermission
-            const seekPermission = paramsReader.readInt8()
-            if (seekPermission >= 0) {
-              args.seekPermission = seekPermission === 1
-            } else {
-              args.seekPermission = undefined
-            }
+          // Serialize the result
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          const publicKeyBytes = Utils.toArray(
+            getPublicKeyResult.publicKey,
+            'hex'
+          )
+          responseWriter.write(publicKeyBytes)
+          return responseWriter.toArray()
+        }
 
-            // Call the method
-            const createHmacResult = await this.wallet.createHmac(args, originator)
+        case 'encrypt': {
+          const args: any = this.decodeKeyRelatedParams(paramsReader)
 
-            // Serialize the result
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            responseWriter.write(createHmacResult.hmac)
-            return responseWriter.toArray()
-          }
+          // Deserialize plaintext
+          const plaintextLength = paramsReader.readVarIntNum()
+          args.plaintext = paramsReader.read(plaintextLength)
 
-        case 'verifyHmac':
-          {
-            const args: any = this.decodeKeyRelatedParams(paramsReader)
+          // Deserialize seekPermission
+          const seekPermission = paramsReader.readInt8()
+          if (seekPermission >= 0) {
+            args.seekPermission = seekPermission === 1
+          } else {
+            args.seekPermission = undefined
+          }
 
-            // Deserialize hmac
-            args.hmac = paramsReader.read(32)
+          // Call the method
+          const encryptResult = await this.wallet.encrypt(args, originator)
 
-            // Deserialize data
-            const dataLength = paramsReader.readVarIntNum()
-            args.data = paramsReader.read(dataLength)
+          // Serialize the result
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.write(encryptResult.ciphertext)
+          return responseWriter.toArray()
+        }
 
-            // Deserialize seekPermission
-            const seekPermission = paramsReader.readInt8()
-            if (seekPermission >= 0) {
-              args.seekPermission = seekPermission === 1
-            } else {
-              args.seekPermission = undefined
-            }
+        case 'decrypt': {
+          const args: any = this.decodeKeyRelatedParams(paramsReader)
 
-            // Call the method
-            await this.wallet.verifyHmac(args, originator)
+          // Deserialize ciphertext
+          const ciphertextLength = paramsReader.readVarIntNum()
+          args.ciphertext = paramsReader.read(ciphertextLength)
 
-            // Serialize the result (no data to return)
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            return responseWriter.toArray()
+          // Deserialize seekPermission
+          const seekPermission = paramsReader.readInt8()
+          if (seekPermission >= 0) {
+            args.seekPermission = seekPermission === 1
+          } else {
+            args.seekPermission = undefined
           }
 
-        case 'createSignature':
-          {
-            const args: any = this.decodeKeyRelatedParams(paramsReader)
+          // Call the method
+          const decryptResult = await this.wallet.decrypt(args, originator)
 
-            // Deserialize data or hashToDirectlySign
-            const dataTypeFlag = paramsReader.readUInt8()
-            if (dataTypeFlag === 1) {
-              const dataLength = paramsReader.readVarIntNum()
-              args.data = paramsReader.read(dataLength)
-            } else if (dataTypeFlag === 2) {
-              args.hashToDirectlySign = paramsReader.read(32)
-            }
+          // Serialize the result
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.write(decryptResult.plaintext)
+          return responseWriter.toArray()
+        }
 
-            // Deserialize seekPermission
-            const seekPermission = paramsReader.readInt8()
-            if (seekPermission >= 0) {
-              args.seekPermission = seekPermission === 1
-            } else {
-              args.seekPermission = undefined
-            }
+        case 'createHmac': {
+          const args: any = this.decodeKeyRelatedParams(paramsReader)
 
-            // Call the method
-            const createSignatureResult = await this.wallet.createSignature(args, originator)
+          // Deserialize data
+          const dataLength = paramsReader.readVarIntNum()
+          args.data = paramsReader.read(dataLength)
 
-            // Serialize the result
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            responseWriter.write(createSignatureResult.signature)
-            return responseWriter.toArray()
+          // Deserialize seekPermission
+          const seekPermission = paramsReader.readInt8()
+          if (seekPermission >= 0) {
+            args.seekPermission = seekPermission === 1
+          } else {
+            args.seekPermission = undefined
           }
 
-        case 'verifySignature':
-          {
-            const args: any = this.decodeKeyRelatedParams(paramsReader)
+          // Call the method
+          const createHmacResult = await this.wallet.createHmac(
+            args,
+            originator
+          )
 
-            // Deserialize forSelf
-            const forSelfFlag = paramsReader.readInt8()
-            if (forSelfFlag === -1) {
-              args.forSelf = undefined
-            } else {
-              args.forSelf = forSelfFlag === 1
-            }
+          // Serialize the result
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.write(createHmacResult.hmac)
+          return responseWriter.toArray()
+        }
 
-            // Deserialize signature
-            const signatureLength = paramsReader.readVarIntNum()
-            args.signature = paramsReader.read(signatureLength)
-
-            // Deserialize data or hashToDirectlyVerify
-            const dataTypeFlag = paramsReader.readUInt8()
-            if (dataTypeFlag === 1) {
-              const dataLength = paramsReader.readVarIntNum()
-              args.data = paramsReader.read(dataLength)
-            } else if (dataTypeFlag === 2) {
-              args.hashToDirectlyVerify = paramsReader.read(32)
-            }
+        case 'verifyHmac': {
+          const args: any = this.decodeKeyRelatedParams(paramsReader)
 
-            // Deserialize seekPermission
-            const seekPermission = paramsReader.readInt8()
-            if (seekPermission >= 0) {
-              args.seekPermission = seekPermission === 1
-            } else {
-              args.seekPermission = undefined
-            }
+          // Deserialize hmac
+          args.hmac = paramsReader.read(32)
 
-            // Call the method
-            await this.wallet.verifySignature(args, originator)
+          // Deserialize data
+          const dataLength = paramsReader.readVarIntNum()
+          args.data = paramsReader.read(dataLength)
 
-            // Serialize the result (no data to return)
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            return responseWriter.toArray()
+          // Deserialize seekPermission
+          const seekPermission = paramsReader.readInt8()
+          if (seekPermission >= 0) {
+            args.seekPermission = seekPermission === 1
+          } else {
+            args.seekPermission = undefined
           }
 
-        case 'isAuthenticated':
-          {
-            // No parameters to deserialize
+          // Call the method
+          await this.wallet.verifyHmac(args, originator)
 
-            // Call the method
-            const isAuthenticatedResult = await this.wallet.isAuthenticated({}, originator)
+          // Serialize the result (no data to return)
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          return responseWriter.toArray()
+        }
 
-            // Serialize the result
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            responseWriter.writeUInt8(isAuthenticatedResult.authenticated ? 1 : 0)
-            return responseWriter.toArray()
+        case 'createSignature': {
+          const args: any = this.decodeKeyRelatedParams(paramsReader)
+
+          // Deserialize data or hashToDirectlySign
+          const dataTypeFlag = paramsReader.readUInt8()
+          if (dataTypeFlag === 1) {
+            const dataLength = paramsReader.readVarIntNum()
+            args.data = paramsReader.read(dataLength)
+          } else if (dataTypeFlag === 2) {
+            args.hashToDirectlySign = paramsReader.read(32)
+          }
+
+          // Deserialize seekPermission
+          const seekPermission = paramsReader.readInt8()
+          if (seekPermission >= 0) {
+            args.seekPermission = seekPermission === 1
+          } else {
+            args.seekPermission = undefined
           }
 
-        case 'waitForAuthentication':
-          {
-            // No parameters to deserialize
+          // Call the method
+          const createSignatureResult = await this.wallet.createSignature(
+            args,
+            originator
+          )
 
-            // Call the method
-            await this.wallet.waitForAuthentication({}, originator)
+          // Serialize the result
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.write(createSignatureResult.signature)
+          return responseWriter.toArray()
+        }
+
+        case 'verifySignature': {
+          const args: any = this.decodeKeyRelatedParams(paramsReader)
 
-            // Serialize the result (authenticated is always true)
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            return responseWriter.toArray()
+          // Deserialize forSelf
+          const forSelfFlag = paramsReader.readInt8()
+          if (forSelfFlag === -1) {
+            args.forSelf = undefined
+          } else {
+            args.forSelf = forSelfFlag === 1
           }
 
-        case 'getHeight':
-          {
-            // No parameters to deserialize
+          // Deserialize signature
+          const signatureLength = paramsReader.readVarIntNum()
+          args.signature = paramsReader.read(signatureLength)
 
-            // Call the method
-            const getHeightResult = await this.wallet.getHeight({}, originator)
+          // Deserialize data or hashToDirectlyVerify
+          const dataTypeFlag = paramsReader.readUInt8()
+          if (dataTypeFlag === 1) {
+            const dataLength = paramsReader.readVarIntNum()
+            args.data = paramsReader.read(dataLength)
+          } else if (dataTypeFlag === 2) {
+            args.hashToDirectlyVerify = paramsReader.read(32)
+          }
 
-            // Serialize the result
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            responseWriter.writeVarIntNum(getHeightResult.height)
-            return responseWriter.toArray()
+          // Deserialize seekPermission
+          const seekPermission = paramsReader.readInt8()
+          if (seekPermission >= 0) {
+            args.seekPermission = seekPermission === 1
+          } else {
+            args.seekPermission = undefined
           }
 
-        case 'getHeaderForHeight':
-          {
-            const args: any = {}
+          // Call the method
+          await this.wallet.verifySignature(args, originator)
 
-            // Deserialize height
-            args.height = paramsReader.readVarIntNum()
+          // Serialize the result (no data to return)
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          return responseWriter.toArray()
+        }
 
-            // Call the method
-            const getHeaderResult = await this.wallet.getHeaderForHeight(args, originator)
+        case 'isAuthenticated': {
+          // No parameters to deserialize
 
-            // Serialize the result
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            const headerBytes = Utils.toArray(getHeaderResult.header, 'hex')
-            responseWriter.write(headerBytes)
-            return responseWriter.toArray()
-          }
+          // Call the method
+          const isAuthenticatedResult = await this.wallet.isAuthenticated(
+            {},
+            originator
+          )
 
-        case 'getNetwork':
-          {
-            // No parameters to deserialize
+          // Serialize the result
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.writeUInt8(
+            isAuthenticatedResult.authenticated ? 1 : 0
+          )
+          return responseWriter.toArray()
+        }
 
-            // Call the method
-            const getNetworkResult = await this.wallet.getNetwork({}, originator)
+        case 'waitForAuthentication': {
+          // No parameters to deserialize
 
-            // Serialize the result
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            responseWriter.writeUInt8(getNetworkResult.network === 'mainnet' ? 0 : 1)
-            return responseWriter.toArray()
-          }
+          // Call the method
+          await this.wallet.waitForAuthentication({}, originator)
 
-        case 'getVersion':
-          {
-            // No parameters to deserialize
+          // Serialize the result (authenticated is always true)
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          return responseWriter.toArray()
+        }
 
-            // Call the method
-            const getVersionResult = await this.wallet.getVersion({}, originator)
+        case 'getHeight': {
+          // No parameters to deserialize
 
-            // Serialize the result
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            const versionBytes = Utils.toArray(getVersionResult.version, 'utf8')
-            responseWriter.write(versionBytes)
-            return responseWriter.toArray()
-          }
+          // Call the method
+          const getHeightResult = await this.wallet.getHeight({}, originator)
 
-        case 'revealCounterpartyKeyLinkage':
-          {
-            const args: any = {}
+          // Serialize the result
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.writeVarIntNum(getHeightResult.height)
+          return responseWriter.toArray()
+        }
 
-            // Read privileged parameters
-            const privilegedFlag = paramsReader.readInt8()
-            if (privilegedFlag === -1) {
-              args.privileged = undefined
-            } else {
-              args.privileged = privilegedFlag === 1
-            }
+        case 'getHeaderForHeight': {
+          const args: any = {}
 
-            const privilegedReasonLength = paramsReader.readInt8()
-            if (privilegedReasonLength === -1) {
-              args.privilegedReason = undefined
-            } else {
-              const privilegedReasonBytes = paramsReader.read(privilegedReasonLength)
-              args.privilegedReason = Utils.toUTF8(privilegedReasonBytes)
-            }
+          // Deserialize height
+          args.height = paramsReader.readVarIntNum()
 
-            // Read counterparty public key
-            const counterpartyBytes = paramsReader.read(33)
-            args.counterparty = Utils.toHex(counterpartyBytes)
+          // Call the method
+          const getHeaderResult = await this.wallet.getHeaderForHeight(
+            args,
+            originator
+          )
 
-            // Read verifier public key
-            const verifierBytes = paramsReader.read(33)
-            args.verifier = Utils.toHex(verifierBytes)
+          // Serialize the result
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          const headerBytes = Utils.toArray(getHeaderResult.header, 'hex')
+          responseWriter.write(headerBytes)
+          return responseWriter.toArray()
+        }
 
-            // Call the method
-            const revealResult = await this.wallet.revealCounterpartyKeyLinkage(args, originator)
+        case 'getNetwork': {
+          // No parameters to deserialize
 
-            // Serialize the result
-            const resultWriter = new Utils.Writer()
+          // Call the method
+          const getNetworkResult = await this.wallet.getNetwork({}, originator)
 
-            // Write prover
-            resultWriter.write(Utils.toArray(revealResult.prover, 'hex'))
+          // Serialize the result
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.writeUInt8(
+            getNetworkResult.network === 'mainnet' ? 0 : 1
+          )
+          return responseWriter.toArray()
+        }
 
-            // Write verifier
-            resultWriter.write(Utils.toArray(revealResult.verifier, 'hex'))
+        case 'getVersion': {
+          // No parameters to deserialize
 
-            // Write counterparty
-            resultWriter.write(Utils.toArray(revealResult.counterparty, 'hex'))
+          // Call the method
+          const getVersionResult = await this.wallet.getVersion({}, originator)
 
-            // Write revelationTime
-            const revelationTimeBytes = Utils.toArray(revealResult.revelationTime, 'utf8')
-            resultWriter.writeVarIntNum(revelationTimeBytes.length)
-            resultWriter.write(revelationTimeBytes)
+          // Serialize the result
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          const versionBytes = Utils.toArray(getVersionResult.version, 'utf8')
+          responseWriter.write(versionBytes)
+          return responseWriter.toArray()
+        }
 
-            // Write encryptedLinkage
-            resultWriter.writeVarIntNum(revealResult.encryptedLinkage.length)
-            resultWriter.write(revealResult.encryptedLinkage)
+        case 'revealCounterpartyKeyLinkage': {
+          const args: any = {}
 
-            // Write encryptedLinkageProof
-            resultWriter.writeVarIntNum(revealResult.encryptedLinkageProof.length)
-            resultWriter.write(revealResult.encryptedLinkageProof)
+          // Read privileged parameters
+          const privilegedFlag = paramsReader.readInt8()
+          if (privilegedFlag === -1) {
+            args.privileged = undefined
+          } else {
+            args.privileged = privilegedFlag === 1
+          }
 
-            // Return success code and result
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            responseWriter.write(resultWriter.toArray())
-            return responseWriter.toArray()
+          const privilegedReasonLength = paramsReader.readInt8()
+          if (privilegedReasonLength === -1) {
+            args.privilegedReason = undefined
+          } else {
+            const privilegedReasonBytes = paramsReader.read(
+              privilegedReasonLength
+            )
+            args.privilegedReason = Utils.toUTF8(privilegedReasonBytes)
           }
 
-        case 'revealSpecificKeyLinkage':
-          {
-            // Deserialize key-related parameters and privileged parameters
-            const args = this.decodeKeyRelatedParams(paramsReader)
+          // Read counterparty public key
+          const counterpartyBytes = paramsReader.read(33)
+          args.counterparty = Utils.toHex(counterpartyBytes)
 
-            // Read verifier public key
-            const verifierBytes = paramsReader.read(33)
-            args.verifier = Utils.toHex(verifierBytes)
+          // Read verifier public key
+          const verifierBytes = paramsReader.read(33)
+          args.verifier = Utils.toHex(verifierBytes)
 
-            // Call the method
-            const revealResult = await this.wallet.revealSpecificKeyLinkage(args, originator)
+          // Call the method
+          const revealResult = await this.wallet.revealCounterpartyKeyLinkage(
+            args,
+            originator
+          )
 
-            // Serialize the result
-            const resultWriter = new Utils.Writer()
+          // Serialize the result
+          const resultWriter = new Utils.Writer()
 
-            // Write prover
-            resultWriter.write(Utils.toArray(revealResult.prover, 'hex'))
+          // Write prover
+          resultWriter.write(Utils.toArray(revealResult.prover, 'hex'))
 
-            // Write verifier
-            resultWriter.write(Utils.toArray(revealResult.verifier, 'hex'))
+          // Write verifier
+          resultWriter.write(Utils.toArray(revealResult.verifier, 'hex'))
 
-            // Write counterparty
-            resultWriter.write(Utils.toArray(revealResult.counterparty, 'hex'))
+          // Write counterparty
+          resultWriter.write(Utils.toArray(revealResult.counterparty, 'hex'))
 
-            // Write securityLevel
-            resultWriter.writeUInt8(revealResult.protocolID[0])
+          // Write revelationTime
+          const revelationTimeBytes = Utils.toArray(
+            revealResult.revelationTime,
+            'utf8'
+          )
+          resultWriter.writeVarIntNum(revelationTimeBytes.length)
+          resultWriter.write(revelationTimeBytes)
 
-            // Write protocol string
-            const protocolBytesOut = Utils.toArray(revealResult.protocolID[1], 'utf8')
-            resultWriter.writeVarIntNum(protocolBytesOut.length)
-            resultWriter.write(protocolBytesOut)
+          // Write encryptedLinkage
+          resultWriter.writeVarIntNum(revealResult.encryptedLinkage.length)
+          resultWriter.write(revealResult.encryptedLinkage)
 
-            // Write keyID
-            const keyIDBytesOut = Utils.toArray(revealResult.keyID, 'utf8')
-            resultWriter.writeVarIntNum(keyIDBytesOut.length)
-            resultWriter.write(keyIDBytesOut)
+          // Write encryptedLinkageProof
+          resultWriter.writeVarIntNum(
+            revealResult.encryptedLinkageProof.length
+          )
+          resultWriter.write(revealResult.encryptedLinkageProof)
 
-            // Write encryptedLinkage
-            resultWriter.writeVarIntNum(revealResult.encryptedLinkage.length)
-            resultWriter.write(revealResult.encryptedLinkage)
+          // Return success code and result
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.write(resultWriter.toArray())
+          return responseWriter.toArray()
+        }
 
-            // Write encryptedLinkageProof
-            resultWriter.writeVarIntNum(revealResult.encryptedLinkageProof.length)
-            resultWriter.write(revealResult.encryptedLinkageProof)
+        case 'revealSpecificKeyLinkage': {
+          // Deserialize key-related parameters and privileged parameters
+          const args = this.decodeKeyRelatedParams(paramsReader)
 
-            // Write proofType
-            resultWriter.writeUInt8(revealResult.proofType)
+          // Read verifier public key
+          const verifierBytes = paramsReader.read(33)
+          args.verifier = Utils.toHex(verifierBytes)
 
-            // Return success code and result
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            responseWriter.write(resultWriter.toArray())
-            return responseWriter.toArray()
-          }
+          // Call the method
+          const revealResult = await this.wallet.revealSpecificKeyLinkage(
+            args,
+            originator
+          )
 
-        case 'acquireCertificate':
-          {
-            const args: any = {}
+          // Serialize the result
+          const resultWriter = new Utils.Writer()
 
-            // Read args.type
-            const typeBytes = paramsReader.read(32)
-            args.type = Utils.toBase64(typeBytes)
+          // Write prover
+          resultWriter.write(Utils.toArray(revealResult.prover, 'hex'))
 
-            // args.certifier
-            const certifierBytes = paramsReader.read(33)
-            args.certifier = Utils.toHex(certifierBytes)
+          // Write verifier
+          resultWriter.write(Utils.toArray(revealResult.verifier, 'hex'))
 
-            // Read fields
-            const fieldsLength = paramsReader.readVarIntNum()
-            args.fields = {}
-            for (let i = 0; i < fieldsLength; i++) {
-              const fieldNameLength = paramsReader.readVarIntNum()
-              const fieldNameBytes = paramsReader.read(fieldNameLength)
-              const fieldName = Utils.toUTF8(fieldNameBytes)
+          // Write counterparty
+          resultWriter.write(Utils.toArray(revealResult.counterparty, 'hex'))
 
-              const fieldValueLength = paramsReader.readVarIntNum()
-              const fieldValueBytes = paramsReader.read(fieldValueLength)
-              const fieldValue = Utils.toUTF8(fieldValueBytes)
+          // Write securityLevel
+          resultWriter.writeUInt8(revealResult.protocolID[0])
 
-              args.fields[fieldName] = fieldValue
-            }
+          // Write protocol string
+          const protocolBytesOut = Utils.toArray(
+            revealResult.protocolID[1],
+            'utf8'
+          )
+          resultWriter.writeVarIntNum(protocolBytesOut.length)
+          resultWriter.write(protocolBytesOut)
 
-            // Read privileged parameters
-            const privilegedFlag = paramsReader.readInt8()
-            if (privilegedFlag === -1) {
-              args.privileged = undefined
-            } else {
-              args.privileged = privilegedFlag === 1
-            }
+          // Write keyID
+          const keyIDBytesOut = Utils.toArray(revealResult.keyID, 'utf8')
+          resultWriter.writeVarIntNum(keyIDBytesOut.length)
+          resultWriter.write(keyIDBytesOut)
 
-            const privilegedReasonLength = paramsReader.readInt8()
-            if (privilegedReasonLength === -1) {
-              args.privilegedReason = undefined
-            } else {
-              const privilegedReasonBytes = paramsReader.read(privilegedReasonLength)
-              args.privilegedReason = Utils.toUTF8(privilegedReasonBytes)
-            }
+          // Write encryptedLinkage
+          resultWriter.writeVarIntNum(revealResult.encryptedLinkage.length)
+          resultWriter.write(revealResult.encryptedLinkage)
 
-            // Read acquisitionProtocol
-            const acquisitionProtocolFlag = paramsReader.readUInt8()
-            args.acquisitionProtocol = acquisitionProtocolFlag === 1 ? 'direct' : 'issuance'
+          // Write encryptedLinkageProof
+          resultWriter.writeVarIntNum(
+            revealResult.encryptedLinkageProof.length
+          )
+          resultWriter.write(revealResult.encryptedLinkageProof)
 
-            if (args.acquisitionProtocol === 'direct') {
-              // args.serialNumber
-              const serialNumberBytes = paramsReader.read(32)
-              args.serialNumber = Utils.toBase64(serialNumberBytes)
+          // Write proofType
+          resultWriter.writeUInt8(revealResult.proofType)
 
-              // args.revocationOutpoint
-              args.revocationOutpoint = this.decodeOutpoint(paramsReader)
+          // Return success code and result
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.write(resultWriter.toArray())
+          return responseWriter.toArray()
+        }
 
-              // args.signature
-              const signatureLength = paramsReader.readVarIntNum()
-              const signatureBytes = paramsReader.read(signatureLength)
-              args.signature = Utils.toHex(signatureBytes)
+        case 'acquireCertificate': {
+          const args: any = {}
 
-              // args.keyringRevealer
-              const keyringRevealerIdentifier = paramsReader.readUInt8()
-              if (keyringRevealerIdentifier === 11) {
-                args.keyringRevealer = 'certifier'
-              } else {
-                const keyringRevealerBytes = [keyringRevealerIdentifier].concat(paramsReader.read(32))
-                args.keyringRevealer = Utils.toHex(keyringRevealerBytes)
-              }
+          // Read args.type
+          const typeBytes = paramsReader.read(32)
+          args.type = Utils.toBase64(typeBytes)
 
-              // args.keyringForSubject
-              const keyringEntriesLength = paramsReader.readVarIntNum()
-              args.keyringForSubject = {}
-              for (let i = 0; i < keyringEntriesLength; i++) {
-                const fieldKeyLength = paramsReader.readVarIntNum()
-                const fieldKeyBytes = paramsReader.read(fieldKeyLength)
-                const fieldKey = Utils.toUTF8(fieldKeyBytes)
+          // args.certifier
+          const certifierBytes = paramsReader.read(33)
+          args.certifier = Utils.toHex(certifierBytes)
 
-                const fieldValueLength = paramsReader.readVarIntNum()
-                const fieldValueBytes = paramsReader.read(fieldValueLength)
-                const fieldValue = Utils.toBase64(fieldValueBytes)
+          // Read fields
+          const fieldsLength = paramsReader.readVarIntNum()
+          args.fields = {}
+          for (let i = 0; i < fieldsLength; i++) {
+            const fieldNameLength = paramsReader.readVarIntNum()
+            const fieldNameBytes = paramsReader.read(fieldNameLength)
+            const fieldName = Utils.toUTF8(fieldNameBytes)
 
-                args.keyringForSubject[fieldKey] = fieldValue
-              }
-            } else {
-              // args.certifierUrl
-              const certifierUrlLength = paramsReader.readVarIntNum()
-              const certifierUrlBytes = paramsReader.read(certifierUrlLength)
-              args.certifierUrl = Utils.toUTF8(certifierUrlBytes)
-            }
+            const fieldValueLength = paramsReader.readVarIntNum()
+            const fieldValueBytes = paramsReader.read(fieldValueLength)
+            const fieldValue = Utils.toUTF8(fieldValueBytes)
 
-            // Call the method
-            const acquireResult = await this.wallet.acquireCertificate(args, originator)
-
-            // Serialize the certificate (assuming Certificate class is available)
-            const cert = new Certificate(
-              acquireResult.type,
-              acquireResult.serialNumber,
-              acquireResult.subject,
-              acquireResult.certifier,
-              acquireResult.revocationOutpoint,
-              acquireResult.fields,
-              acquireResult.signature
-            )
-            const certBin = cert.toBinary()
+            args.fields[fieldName] = fieldValue
+          }
 
-            // Return success code and certificate binary
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            responseWriter.write(certBin)
-            return responseWriter.toArray()
+          // Read privileged parameters
+          const privilegedFlag = paramsReader.readInt8()
+          if (privilegedFlag === -1) {
+            args.privileged = undefined
+          } else {
+            args.privileged = privilegedFlag === 1
           }
 
-        case 'listCertificates':
-          {
-            const args: any = {}
+          const privilegedReasonLength = paramsReader.readInt8()
+          if (privilegedReasonLength === -1) {
+            args.privilegedReason = undefined
+          } else {
+            const privilegedReasonBytes = paramsReader.read(
+              privilegedReasonLength
+            )
+            args.privilegedReason = Utils.toUTF8(privilegedReasonBytes)
+          }
 
-            // Read certifiers
-            const certifiersLength = paramsReader.readVarIntNum()
-            args.certifiers = []
-            for (let i = 0; i < certifiersLength; i++) {
-              const certifierBytes = paramsReader.read(33)
-              args.certifiers.push(Utils.toHex(certifierBytes))
-            }
+          // Read acquisitionProtocol
+          const acquisitionProtocolFlag = paramsReader.readUInt8()
+          args.acquisitionProtocol =
+            acquisitionProtocolFlag === 1 ? 'direct' : 'issuance'
 
-            // Read types
-            const typesLength = paramsReader.readVarIntNum()
-            args.types = []
-            for (let i = 0; i < typesLength; i++) {
-              const typeBytes = paramsReader.read(32)
-              args.types.push(Utils.toBase64(typeBytes))
-            }
+          if (args.acquisitionProtocol === 'direct') {
+            // args.serialNumber
+            const serialNumberBytes = paramsReader.read(32)
+            args.serialNumber = Utils.toBase64(serialNumberBytes)
 
-            // Read limit and offset
-            const limit = paramsReader.readVarIntNum()
-            if (limit >= 0) {
-              args.limit = limit
-            } else {
-              args.limit = undefined
-            }
+            // args.revocationOutpoint
+            args.revocationOutpoint = this.decodeOutpoint(paramsReader)
 
-            const offset = paramsReader.readVarIntNum()
-            if (offset >= 0) {
-              args.offset = offset
-            } else {
-              args.offset = undefined
-            }
+            // args.signature
+            const signatureLength = paramsReader.readVarIntNum()
+            const signatureBytes = paramsReader.read(signatureLength)
+            args.signature = Utils.toHex(signatureBytes)
 
-            // Read privileged parameters
-            const privilegedFlag = paramsReader.readInt8()
-            if (privilegedFlag === -1) {
-              args.privileged = undefined
+            // args.keyringRevealer
+            const keyringRevealerIdentifier = paramsReader.readUInt8()
+            if (keyringRevealerIdentifier === 11) {
+              args.keyringRevealer = 'certifier'
             } else {
-              args.privileged = privilegedFlag === 1
+              const keyringRevealerBytes = [keyringRevealerIdentifier].concat(
+                paramsReader.read(32)
+              )
+              args.keyringRevealer = Utils.toHex(keyringRevealerBytes)
             }
 
-            const privilegedReasonLength = paramsReader.readInt8()
-            if (privilegedReasonLength === -1) {
-              args.privilegedReason = undefined
-            } else {
-              const privilegedReasonBytes = paramsReader.read(privilegedReasonLength)
-              args.privilegedReason = Utils.toUTF8(privilegedReasonBytes)
-            }
+            // args.keyringForSubject
+            const keyringEntriesLength = paramsReader.readVarIntNum()
+            args.keyringForSubject = {}
+            for (let i = 0; i < keyringEntriesLength; i++) {
+              const fieldKeyLength = paramsReader.readVarIntNum()
+              const fieldKeyBytes = paramsReader.read(fieldKeyLength)
+              const fieldKey = Utils.toUTF8(fieldKeyBytes)
 
-            // Call the method
-            const listResult = await this.wallet.listCertificates(args, originator)
-
-            // Serialize the result
-            const resultWriter = new Utils.Writer()
-
-            // totalCertificates
-            resultWriter.writeVarIntNum(listResult.totalCertificates)
-
-            // certificates
-            for (const cert of listResult.certificates) {
-              const certificate = new Certificate(
-                cert.type,
-                cert.serialNumber,
-                cert.subject,
-                cert.certifier,
-                cert.revocationOutpoint,
-                cert.fields,
-                cert.signature
-              )
-              const certBin = certificate.toBinary()
+              const fieldValueLength = paramsReader.readVarIntNum()
+              const fieldValueBytes = paramsReader.read(fieldValueLength)
+              const fieldValue = Utils.toBase64(fieldValueBytes)
 
-              // Write certificate binary length and data
-              resultWriter.writeVarIntNum(certBin.length)
-              resultWriter.write(certBin)
+              args.keyringForSubject[fieldKey] = fieldValue
             }
-
-            // Return the response
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            responseWriter.write(resultWriter.toArray())
-            return responseWriter.toArray()
+          } else {
+            // args.certifierUrl
+            const certifierUrlLength = paramsReader.readVarIntNum()
+            const certifierUrlBytes = paramsReader.read(certifierUrlLength)
+            args.certifierUrl = Utils.toUTF8(certifierUrlBytes)
           }
 
-        case 'proveCertificate':
-          {
-            const args: any = {}
+          // Call the method
+          const acquireResult = await this.wallet.acquireCertificate(
+            args,
+            originator
+          )
+
+          // Serialize the certificate (assuming Certificate class is available)
+          const cert = new Certificate(
+            acquireResult.type,
+            acquireResult.serialNumber,
+            acquireResult.subject,
+            acquireResult.certifier,
+            acquireResult.revocationOutpoint,
+            acquireResult.fields,
+            acquireResult.signature
+          )
+          const certBin = cert.toBinary()
+
+          // Return success code and certificate binary
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.write(certBin)
+          return responseWriter.toArray()
+        }
+
+        case 'listCertificates': {
+          const args: any = {}
 
-            // Read certificate
-            const cert: any = {}
+          // Read certifiers
+          const certifiersLength = paramsReader.readVarIntNum()
+          args.certifiers = []
+          for (let i = 0; i < certifiersLength; i++) {
+            const certifierBytes = paramsReader.read(33)
+            args.certifiers.push(Utils.toHex(certifierBytes))
+          }
 
-            // Read type
+          // Read types
+          const typesLength = paramsReader.readVarIntNum()
+          args.types = []
+          for (let i = 0; i < typesLength; i++) {
             const typeBytes = paramsReader.read(32)
-            cert.type = Utils.toBase64(typeBytes)
+            args.types.push(Utils.toBase64(typeBytes))
+          }
 
-            // Read subject
-            const subjectBytes = paramsReader.read(33)
-            cert.subject = Utils.toHex(subjectBytes)
+          // Read limit and offset
+          const limit = paramsReader.readVarIntNum()
+          if (limit >= 0) {
+            args.limit = limit
+          } else {
+            args.limit = undefined
+          }
 
-            // Read serialNumber
-            const serialNumberBytes = paramsReader.read(32)
-            cert.serialNumber = Utils.toBase64(serialNumberBytes)
+          const offset = paramsReader.readVarIntNum()
+          if (offset >= 0) {
+            args.offset = offset
+          } else {
+            args.offset = undefined
+          }
 
-            // Read certifier
-            const certifierBytes = paramsReader.read(33)
-            cert.certifier = Utils.toHex(certifierBytes)
+          // Read privileged parameters
+          const privilegedFlag = paramsReader.readInt8()
+          if (privilegedFlag === -1) {
+            args.privileged = undefined
+          } else {
+            args.privileged = privilegedFlag === 1
+          }
+
+          const privilegedReasonLength = paramsReader.readInt8()
+          if (privilegedReasonLength === -1) {
+            args.privilegedReason = undefined
+          } else {
+            const privilegedReasonBytes = paramsReader.read(
+              privilegedReasonLength
+            )
+            args.privilegedReason = Utils.toUTF8(privilegedReasonBytes)
+          }
 
-            // Read revocationOutpoint
-            cert.revocationOutpoint = this.decodeOutpoint(paramsReader)
+          // Call the method
+          const listResult = await this.wallet.listCertificates(
+            args,
+            originator
+          )
 
-            // Read signature
-            const signatureLength = paramsReader.readVarIntNum()
-            const signatureBytes = paramsReader.read(signatureLength)
-            cert.signature = Utils.toHex(signatureBytes)
+          // Serialize the result
+          const resultWriter = new Utils.Writer()
 
-            // Read fields
-            const fieldsLength = paramsReader.readVarIntNum()
-            cert.fields = {}
-            for (let i = 0; i < fieldsLength; i++) {
-              const fieldNameLength = paramsReader.readVarIntNum()
-              const fieldNameBytes = paramsReader.read(fieldNameLength)
-              const fieldName = Utils.toUTF8(fieldNameBytes)
+          // totalCertificates
+          resultWriter.writeVarIntNum(listResult.totalCertificates)
+
+          // certificates
+          for (const cert of listResult.certificates) {
+            const certificate = new Certificate(
+              cert.type,
+              cert.serialNumber,
+              cert.subject,
+              cert.certifier,
+              cert.revocationOutpoint,
+              cert.fields,
+              cert.signature
+            )
+            const certBin = certificate.toBinary()
 
-              const fieldValueLength = paramsReader.readVarIntNum()
-              const fieldValueBytes = paramsReader.read(fieldValueLength)
-              const fieldValue = Utils.toUTF8(fieldValueBytes)
+            // Write certificate binary length and data
+            resultWriter.writeVarIntNum(certBin.length)
+            resultWriter.write(certBin)
+          }
 
-              cert.fields[fieldName] = fieldValue
-            }
+          // Return the response
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.write(resultWriter.toArray())
+          return responseWriter.toArray()
+        }
 
-            args.certificate = cert
+        case 'proveCertificate': {
+          const args: any = {}
 
-            // Read fields to reveal
-            const fieldsToRevealLength = paramsReader.readVarIntNum()
-            args.fieldsToReveal = []
-            for (let i = 0; i < fieldsToRevealLength; i++) {
-              const fieldNameLength = paramsReader.readVarIntNum()
-              const fieldNameBytes = paramsReader.read(fieldNameLength)
-              const fieldName = Utils.toUTF8(fieldNameBytes)
-              args.fieldsToReveal.push(fieldName)
-            }
+          // Read certificate
+          const cert: any = {}
 
-            // Read verifier
-            const verifierBytes = paramsReader.read(33)
-            args.verifier = Utils.toHex(verifierBytes)
+          // Read type
+          const typeBytes = paramsReader.read(32)
+          cert.type = Utils.toBase64(typeBytes)
 
-            // Read privileged parameters
-            const privilegedFlag = paramsReader.readInt8()
-            if (privilegedFlag === -1) {
-              args.privileged = undefined
-            } else {
-              args.privileged = privilegedFlag === 1
-            }
+          // Read subject
+          const subjectBytes = paramsReader.read(33)
+          cert.subject = Utils.toHex(subjectBytes)
 
-            const privilegedReasonLength = paramsReader.readInt8()
-            if (privilegedReasonLength === -1) {
-              args.privilegedReason = undefined
-            } else {
-              const privilegedReasonBytes = paramsReader.read(privilegedReasonLength)
-              args.privilegedReason = Utils.toUTF8(privilegedReasonBytes)
-            }
+          // Read serialNumber
+          const serialNumberBytes = paramsReader.read(32)
+          cert.serialNumber = Utils.toBase64(serialNumberBytes)
 
-            // Call the method
-            const proveResult = await this.wallet.proveCertificate(args, originator)
+          // Read certifier
+          const certifierBytes = paramsReader.read(33)
+          cert.certifier = Utils.toHex(certifierBytes)
 
-            // Serialize keyringForVerifier
-            const resultWriter = new Utils.Writer()
+          // Read revocationOutpoint
+          cert.revocationOutpoint = this.decodeOutpoint(paramsReader)
 
-            const keyringEntries = Object.entries(proveResult.keyringForVerifier)
-            resultWriter.writeVarIntNum(keyringEntries.length)
-            for (const [fieldName, fieldValue] of keyringEntries) {
-              const fieldNameBytes = Utils.toArray(fieldName, 'utf8')
-              resultWriter.writeVarIntNum(fieldNameBytes.length)
-              resultWriter.write(fieldNameBytes)
+          // Read signature
+          const signatureLength = paramsReader.readVarIntNum()
+          const signatureBytes = paramsReader.read(signatureLength)
+          cert.signature = Utils.toHex(signatureBytes)
 
-              const fieldValueBytes = Utils.toArray(fieldValue, 'base64')
-              resultWriter.writeVarIntNum(fieldValueBytes.length)
-              resultWriter.write(fieldValueBytes)
-            }
+          // Read fields
+          const fieldsLength = paramsReader.readVarIntNum()
+          cert.fields = {}
+          for (let i = 0; i < fieldsLength; i++) {
+            const fieldNameLength = paramsReader.readVarIntNum()
+            const fieldNameBytes = paramsReader.read(fieldNameLength)
+            const fieldName = Utils.toUTF8(fieldNameBytes)
 
-            // Return the response
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            responseWriter.write(resultWriter.toArray())
-            return responseWriter.toArray()
+            const fieldValueLength = paramsReader.readVarIntNum()
+            const fieldValueBytes = paramsReader.read(fieldValueLength)
+            const fieldValue = Utils.toUTF8(fieldValueBytes)
+
+            cert.fields[fieldName] = fieldValue
           }
 
-        case 'relinquishCertificate':
-          {
-            const args: any = {}
+          args.certificate = cert
 
-            // Read type
-            const typeBytes = paramsReader.read(32)
-            args.type = Utils.toBase64(typeBytes)
+          // Read fields to reveal
+          const fieldsToRevealLength = paramsReader.readVarIntNum()
+          args.fieldsToReveal = []
+          for (let i = 0; i < fieldsToRevealLength; i++) {
+            const fieldNameLength = paramsReader.readVarIntNum()
+            const fieldNameBytes = paramsReader.read(fieldNameLength)
+            const fieldName = Utils.toUTF8(fieldNameBytes)
+            args.fieldsToReveal.push(fieldName)
+          }
 
-            // Read serialNumber
-            const serialNumberBytes = paramsReader.read(32)
-            args.serialNumber = Utils.toBase64(serialNumberBytes)
+          // Read verifier
+          const verifierBytes = paramsReader.read(33)
+          args.verifier = Utils.toHex(verifierBytes)
 
-            // Read certifier
-            const certifierBytes = paramsReader.read(33)
-            args.certifier = Utils.toHex(certifierBytes)
+          // Read privileged parameters
+          const privilegedFlag = paramsReader.readInt8()
+          if (privilegedFlag === -1) {
+            args.privileged = undefined
+          } else {
+            args.privileged = privilegedFlag === 1
+          }
+
+          const privilegedReasonLength = paramsReader.readInt8()
+          if (privilegedReasonLength === -1) {
+            args.privilegedReason = undefined
+          } else {
+            const privilegedReasonBytes = paramsReader.read(
+              privilegedReasonLength
+            )
+            args.privilegedReason = Utils.toUTF8(privilegedReasonBytes)
+          }
+
+          // Call the method
+          const proveResult = await this.wallet.proveCertificate(
+            args,
+            originator
+          )
+
+          // Serialize keyringForVerifier
+          const resultWriter = new Utils.Writer()
 
-            // Call the method
-            await this.wallet.relinquishCertificate(args, originator)
+          const keyringEntries = Object.entries(proveResult.keyringForVerifier)
+          resultWriter.writeVarIntNum(keyringEntries.length)
+          for (const [fieldName, fieldValue] of keyringEntries) {
+            const fieldNameBytes = Utils.toArray(fieldName, 'utf8')
+            resultWriter.writeVarIntNum(fieldNameBytes.length)
+            resultWriter.write(fieldNameBytes)
 
-            // Return success code
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            return responseWriter.toArray()
+            const fieldValueBytes = Utils.toArray(fieldValue, 'base64')
+            resultWriter.writeVarIntNum(fieldValueBytes.length)
+            resultWriter.write(fieldValueBytes)
           }
 
-        case 'discoverByIdentityKey':
-          {
-            const args: any = {}
+          // Return the response
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.write(resultWriter.toArray())
+          return responseWriter.toArray()
+        }
 
-            // Read identityKey
-            const identityKeyBytes = paramsReader.read(33)
-            args.identityKey = Utils.toHex(identityKeyBytes)
+        case 'relinquishCertificate': {
+          const args: any = {}
 
-            // Read limit and offset
-            const limit = paramsReader.readVarIntNum()
-            if (limit >= 0) {
-              args.limit = limit
-            } else {
-              args.limit = undefined
-            }
+          // Read type
+          const typeBytes = paramsReader.read(32)
+          args.type = Utils.toBase64(typeBytes)
 
-            const offset = paramsReader.readVarIntNum()
-            if (offset >= 0) {
-              args.offset = offset
-            } else {
-              args.offset = undefined
-            }
+          // Read serialNumber
+          const serialNumberBytes = paramsReader.read(32)
+          args.serialNumber = Utils.toBase64(serialNumberBytes)
 
-            // Deserialize seekPermission
-            const seekPermission = paramsReader.readInt8()
-            if (seekPermission >= 0) {
-              args.seekPermission = seekPermission === 1
-            } else {
-              args.seekPermission = undefined
-            }
+          // Read certifier
+          const certifierBytes = paramsReader.read(33)
+          args.certifier = Utils.toHex(certifierBytes)
 
-            // Call the method
-            const discoverResult = await this.wallet.discoverByIdentityKey(args, originator)
+          // Call the method
+          await this.wallet.relinquishCertificate(args, originator)
 
-            // Serialize the result
-            const result = this.serializeDiscoveryResult(discoverResult)
+          // Return success code
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          return responseWriter.toArray()
+        }
+
+        case 'discoverByIdentityKey': {
+          const args: any = {}
+
+          // Read identityKey
+          const identityKeyBytes = paramsReader.read(33)
+          args.identityKey = Utils.toHex(identityKeyBytes)
 
-            // Return the response
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            responseWriter.write(result)
-            return responseWriter.toArray()
+          // Read limit and offset
+          const limit = paramsReader.readVarIntNum()
+          if (limit >= 0) {
+            args.limit = limit
+          } else {
+            args.limit = undefined
           }
 
-        case 'discoverByAttributes':
-          {
-            const args: any = {}
+          const offset = paramsReader.readVarIntNum()
+          if (offset >= 0) {
+            args.offset = offset
+          } else {
+            args.offset = undefined
+          }
 
-            // Read attributes
-            const attributesLength = paramsReader.readVarIntNum()
-            args.attributes = {}
-            for (let i = 0; i < attributesLength; i++) {
-              const fieldKeyLength = paramsReader.readVarIntNum()
-              const fieldKeyBytes = paramsReader.read(fieldKeyLength)
-              const fieldKey = Utils.toUTF8(fieldKeyBytes)
+          // Deserialize seekPermission
+          const seekPermission = paramsReader.readInt8()
+          if (seekPermission >= 0) {
+            args.seekPermission = seekPermission === 1
+          } else {
+            args.seekPermission = undefined
+          }
 
-              const fieldValueLength = paramsReader.readVarIntNum()
-              const fieldValueBytes = paramsReader.read(fieldValueLength)
-              const fieldValue = Utils.toUTF8(fieldValueBytes)
+          // Call the method
+          const discoverResult = await this.wallet.discoverByIdentityKey(
+            args,
+            originator
+          )
 
-              args.attributes[fieldKey] = fieldValue
-            }
+          // Serialize the result
+          const result = this.serializeDiscoveryResult(discoverResult)
 
-            // Read limit and offset
-            const limit = paramsReader.readVarIntNum()
-            if (limit >= 0) {
-              args.limit = limit
-            } else {
-              args.limit = undefined
-            }
+          // Return the response
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.write(result)
+          return responseWriter.toArray()
+        }
 
-            const offset = paramsReader.readVarIntNum()
-            if (offset >= 0) {
-              args.offset = offset
-            } else {
-              args.offset = undefined
-            }
+        case 'discoverByAttributes': {
+          const args: any = {}
 
-            // Deserialize seekPermission
-            const seekPermission = paramsReader.readInt8()
-            if (seekPermission >= 0) {
-              args.seekPermission = seekPermission === 1
-            } else {
-              args.seekPermission = undefined
-            }
+          // Read attributes
+          const attributesLength = paramsReader.readVarIntNum()
+          args.attributes = {}
+          for (let i = 0; i < attributesLength; i++) {
+            const fieldKeyLength = paramsReader.readVarIntNum()
+            const fieldKeyBytes = paramsReader.read(fieldKeyLength)
+            const fieldKey = Utils.toUTF8(fieldKeyBytes)
+
+            const fieldValueLength = paramsReader.readVarIntNum()
+            const fieldValueBytes = paramsReader.read(fieldValueLength)
+            const fieldValue = Utils.toUTF8(fieldValueBytes)
 
-            // Call the method
-            const discoverResult = await this.wallet.discoverByAttributes(args, originator)
+            args.attributes[fieldKey] = fieldValue
+          }
+
+          // Read limit and offset
+          const limit = paramsReader.readVarIntNum()
+          if (limit >= 0) {
+            args.limit = limit
+          } else {
+            args.limit = undefined
+          }
 
-            // Serialize the result
-            const result = this.serializeDiscoveryResult(discoverResult)
+          const offset = paramsReader.readVarIntNum()
+          if (offset >= 0) {
+            args.offset = offset
+          } else {
+            args.offset = undefined
+          }
 
-            // Return the response
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            responseWriter.write(result)
-            return responseWriter.toArray()
+          // Deserialize seekPermission
+          const seekPermission = paramsReader.readInt8()
+          if (seekPermission >= 0) {
+            args.seekPermission = seekPermission === 1
+          } else {
+            args.seekPermission = undefined
           }
 
+          // Call the method
+          const discoverResult = await this.wallet.discoverByAttributes(
+            args,
+            originator
+          )
+
+          // Serialize the result
+          const result = this.serializeDiscoveryResult(discoverResult)
+
+          // Return the response
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.write(result)
+          return responseWriter.toArray()
+        }
+
         default:
           throw new Error(`Method ${callName} not implemented`)
       }
     } catch (err) {
       const responseWriter = new Utils.Writer()
-      responseWriter.writeUInt8((err).code || 1) // errorCode = 1 (generic error)
+      responseWriter.writeUInt8(typeof err.code === 'number' ? err.code : 1) // errorCode = 1 (generic error)
 
       // Serialize the error message
-      const errorMessage = err.message || 'Unknown error'
+      const errorMessage = typeof err.message === 'string' ? err.message : 'Unknown error'
       const errorMessageBytes = Utils.toArray(errorMessage, 'utf8')
       responseWriter.writeVarIntNum(errorMessageBytes.length)
       responseWriter.write(errorMessageBytes)
 
       // Serialize the stack trace
-      const stackTrace = err.stack || ''
+      const stackTrace = typeof err.stack === 'string' ? err.stack : ''
       const stackTraceBytes = Utils.toArray(stackTrace, 'utf8')
       responseWriter.writeVarIntNum(stackTraceBytes.length)
       responseWriter.write(stackTraceBytes)
@@ -1929,7 +2059,9 @@ export default class WalletWireProcessor implements WalletWire {
     return Utils.toUTF8(bytes)
   }
 
-  private decodeCounterparty(reader: Utils.Reader): string | 'self' | 'anyone' | undefined {
+  private decodeCounterparty(
+    reader: Utils.Reader
+  ): string | 'self' | 'anyone' | undefined {
     const counterpartyFlag = reader.readUInt8()
     if (counterpartyFlag === 11) {
       return 'self'
@@ -1976,7 +2108,10 @@ export default class WalletWireProcessor implements WalletWire {
       resultWriter.writeVarIntNum(iconUrlBytes.length)
       resultWriter.write(iconUrlBytes)
 
-      const descriptionBytes = Utils.toArray(cert.certifierInfo.description, 'utf8')
+      const descriptionBytes = Utils.toArray(
+        cert.certifierInfo.description,
+        'utf8'
+      )
       resultWriter.writeVarIntNum(descriptionBytes.length)
       resultWriter.write(descriptionBytes)