@bsv/sdk 1.3.12 → 1.3.13

package/src/wallet/substrates/WalletWireProcessor.ts

@@ -1,1953 +1,2086 @@
-import { WalletInterface } 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'
+import { WalletInterface } from "../Wallet.interfaces";
+import WalletWire from "./WalletWire";
+import { Utils } from "../../primitives/index";
+import calls from "./WalletWireCalls";
+import Certificate from "../../auth/certificates/Certificate";
+import { SecurityLevel } from "../Wallet.interfaces";
 
 /**
  * Processes incoming wallet calls received over a wallet wire, with a given wallet.
  */
 export default class WalletWireProcessor implements WalletWire {
-  wallet: WalletInterface
+  wallet: WalletInterface;
 
   constructor(wallet: WalletInterface) {
-    this.wallet = wallet
+    this.wallet = wallet;
   }
 
   private decodeOutpoint(reader: Utils.Reader): string {
-    const txidBytes = reader.read(32)
-    const txid = Utils.toHex(txidBytes)
-    const index = reader.readVarIntNum()
-    return `${txid}.${index}`
+    const txidBytes = reader.read(32);
+    const txid = Utils.toHex(txidBytes);
+    const index = reader.readVarIntNum();
+    return `${txid}.${index}`;
   }
 
   private encodeOutpoint(outpoint: string): number[] {
-    const writer = new Utils.Writer()
-    const [txid, index] = outpoint.split('.')
-    writer.write(Utils.toArray(txid, 'hex'))
-    writer.writeVarIntNum(Number(index))
-    return writer.toArray()
+    const writer = new Utils.Writer();
+    const [txid, index] = outpoint.split(".");
+    writer.write(Utils.toArray(txid, "hex"));
+    writer.writeVarIntNum(Number(index));
+    return writer.toArray();
   }
 
   async transmitToWallet(message: number[]): Promise<number[]> {
-    const messageReader = new Utils.Reader(message)
+    const messageReader = new Utils.Reader(message);
     try {
       // Read call code
-      const callCode = messageReader.readUInt8()
+      const callCode = messageReader.readUInt8();
 
       // Map call code to call name
-      const callName = calls[callCode] // calls is enum
+      const callName = calls[callCode]; // calls is enum
       if (!callName) {
         // Invalid call code
-        throw new Error(`Invalid call code: ${callCode}`)
+        throw new Error(`Invalid call code: ${callCode}`);
       }
 
       // Read originator length
-      const originatorLength = messageReader.readUInt8()
-      const originatorBytes = messageReader.read(originatorLength)
-      const originator = Utils.toUTF8(originatorBytes)
+      const originatorLength = messageReader.readUInt8();
+      const originatorBytes = messageReader.read(originatorLength);
+      const originator = Utils.toUTF8(originatorBytes);
 
       // Read parameters
-      const paramsReader = messageReader // Remaining bytes
+      const paramsReader = messageReader; // Remaining bytes
 
       switch (callName) {
-        case 'createAction':
+        case "createAction":
           // Deserialize parameters from paramsReader
-          const args: any = {}
+          const args: any = {};
 
           // Read description
-          const descriptionLength = paramsReader.readVarIntNum()
-          const descriptionBytes = paramsReader.read(descriptionLength)
-          args.description = Utils.toUTF8(descriptionBytes)
+          const descriptionLength = paramsReader.readVarIntNum();
+          const descriptionBytes = paramsReader.read(descriptionLength);
+          args.description = Utils.toUTF8(descriptionBytes);
 
           // tx
-          const inputBeefLength = paramsReader.readVarIntNum()
+          const inputBeefLength = paramsReader.readVarIntNum();
           if (inputBeefLength >= 0) {
-            args.inputBEEF = paramsReader.read(inputBeefLength) // BEEF (Byte[])
+            args.inputBEEF = paramsReader.read(inputBeefLength); // BEEF (Byte[])
           } else {
-            args.inputBEEF = undefined
+            args.inputBEEF = undefined;
           }
 
           // Read inputs
-          const inputsLength = paramsReader.readVarIntNum()
+          const inputsLength = paramsReader.readVarIntNum();
           if (inputsLength >= 0) {
-            args.inputs = []
+            args.inputs = [];
             for (let i = 0; i < inputsLength; i++) {
-              const input: any = {}
+              const input: any = {};
 
               // outpoint
-              input.outpoint = this.decodeOutpoint(paramsReader)
+              input.outpoint = this.decodeOutpoint(paramsReader);
 
               // unlockingScript / unlockingScriptLength
-              const unlockingScriptLength = paramsReader.readVarIntNum()
+              const unlockingScriptLength = paramsReader.readVarIntNum();
               if (unlockingScriptLength >= 0) {
-                const unlockingScriptBytes = paramsReader.read(unlockingScriptLength)
-                input.unlockingScript = Utils.toHex(unlockingScriptBytes)
+                const unlockingScriptBytes = paramsReader.read(
+                  unlockingScriptLength
+                );
+                input.unlockingScript = Utils.toHex(unlockingScriptBytes);
               } else {
-                input.unlockingScript = undefined
-                const unlockingScriptLengthValue = paramsReader.readVarIntNum()
-                input.unlockingScriptLength = unlockingScriptLengthValue
+                input.unlockingScript = undefined;
+                const unlockingScriptLengthValue = paramsReader.readVarIntNum();
+                input.unlockingScriptLength = unlockingScriptLengthValue;
               }
 
               // inputDescription
-              const inputDescriptionLength = paramsReader.readVarIntNum()
-              const inputDescriptionBytes = paramsReader.read(inputDescriptionLength)
-              input.inputDescription = Utils.toUTF8(inputDescriptionBytes)
+              const inputDescriptionLength = paramsReader.readVarIntNum();
+              const inputDescriptionBytes = paramsReader.read(
+                inputDescriptionLength
+              );
+              input.inputDescription = Utils.toUTF8(inputDescriptionBytes);
 
               // sequenceNumber
-              const sequenceNumber = paramsReader.readVarIntNum()
+              const sequenceNumber = paramsReader.readVarIntNum();
               if (sequenceNumber >= 0) {
-                input.sequenceNumber = sequenceNumber
+                input.sequenceNumber = sequenceNumber;
               } else {
-                input.sequenceNumber = undefined
+                input.sequenceNumber = undefined;
               }
 
-              args.inputs.push(input)
+              args.inputs.push(input);
             }
           } else {
-            args.inputs = undefined
+            args.inputs = undefined;
           }
 
           // Read outputs
-          const outputsLength = paramsReader.readVarIntNum()
+          const outputsLength = paramsReader.readVarIntNum();
           if (outputsLength >= 0) {
-            args.outputs = []
+            args.outputs = [];
             for (let i = 0; i < outputsLength; i++) {
-              const output: any = {}
+              const output: any = {};
 
               // lockingScript
-              const lockingScriptLength = paramsReader.readVarIntNum()
-              const lockingScriptBytes = paramsReader.read(lockingScriptLength)
-              output.lockingScript = Utils.toHex(lockingScriptBytes)
+              const lockingScriptLength = paramsReader.readVarIntNum();
+              const lockingScriptBytes = paramsReader.read(lockingScriptLength);
+              output.lockingScript = Utils.toHex(lockingScriptBytes);
 
               // satoshis
-              output.satoshis = paramsReader.readVarIntNum()
+              output.satoshis = paramsReader.readVarIntNum();
 
               // outputDescription
-              const outputDescriptionLength = paramsReader.readVarIntNum()
-              const outputDescriptionBytes = paramsReader.read(outputDescriptionLength)
-              output.outputDescription = Utils.toUTF8(outputDescriptionBytes)
+              const outputDescriptionLength = paramsReader.readVarIntNum();
+              const outputDescriptionBytes = paramsReader.read(
+                outputDescriptionLength
+              );
+              output.outputDescription = Utils.toUTF8(outputDescriptionBytes);
 
               // basket
-              const basketLength = paramsReader.readVarIntNum()
+              const basketLength = paramsReader.readVarIntNum();
               if (basketLength >= 0) {
-                const basketBytes = paramsReader.read(basketLength)
-                output.basket = Utils.toUTF8(basketBytes)
+                const basketBytes = paramsReader.read(basketLength);
+                output.basket = Utils.toUTF8(basketBytes);
               } else {
-                output.basket = undefined
+                output.basket = undefined;
               }
 
               // customInstructions
-              const customInstructionsLength = paramsReader.readVarIntNum()
+              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
+                output.customInstructions = undefined;
               }
 
               // tags
-              const tagsLength = paramsReader.readVarIntNum()
+              const tagsLength = paramsReader.readVarIntNum();
               if (tagsLength >= 0) {
-                output.tags = []
+                output.tags = [];
                 for (let j = 0; j < tagsLength; j++) {
-                  const tagLength = paramsReader.readVarIntNum()
-                  const tagBytes = paramsReader.read(tagLength)
-                  const tag = Utils.toUTF8(tagBytes)
-                  output.tags.push(tag)
+                  const tagLength = paramsReader.readVarIntNum();
+                  const tagBytes = paramsReader.read(tagLength);
+                  const tag = Utils.toUTF8(tagBytes);
+                  output.tags.push(tag);
                 }
               } else {
-                output.tags = undefined
+                output.tags = undefined;
               }
 
-              args.outputs.push(output)
+              args.outputs.push(output);
             }
           } else {
-            args.outputs = undefined
+            args.outputs = undefined;
           }
 
           // lockTime
-          const lockTime = paramsReader.readVarIntNum()
+          const lockTime = paramsReader.readVarIntNum();
           if (lockTime >= 0) {
-            args.lockTime = lockTime
+            args.lockTime = lockTime;
           } else {
-            args.lockTime = undefined
+            args.lockTime = undefined;
           }
 
           // version
-          const version = paramsReader.readVarIntNum()
+          const version = paramsReader.readVarIntNum();
           if (version >= 0) {
-            args.version = version
+            args.version = version;
           } else {
-            args.version = undefined
+            args.version = undefined;
           }
 
           // labels
-          const labelsLength = paramsReader.readVarIntNum()
+          const labelsLength = paramsReader.readVarIntNum();
           if (labelsLength >= 0) {
-            args.labels = []
+            args.labels = [];
             for (let i = 0; i < labelsLength; i++) {
-              const labelLength = paramsReader.readVarIntNum()
-              const labelBytes = paramsReader.read(labelLength)
-              const label = Utils.toUTF8(labelBytes)
-              args.labels.push(label)
+              const labelLength = paramsReader.readVarIntNum();
+              const labelBytes = paramsReader.read(labelLength);
+              const label = Utils.toUTF8(labelBytes);
+              args.labels.push(label);
             }
           } else {
-            args.labels = undefined
+            args.labels = undefined;
           }
 
           // options
-          const optionsPresent = paramsReader.readInt8()
+          const optionsPresent = paramsReader.readInt8();
           if (optionsPresent === 1) {
-            args.options = {}
+            args.options = {};
 
             // signAndProcess
-            const signAndProcessFlag = paramsReader.readInt8()
+            const signAndProcessFlag = paramsReader.readInt8();
             if (signAndProcessFlag === -1) {
-              args.options.signAndProcess = undefined
+              args.options.signAndProcess = undefined;
             } else {
-              args.options.signAndProcess = signAndProcessFlag === 1
+              args.options.signAndProcess = signAndProcessFlag === 1;
             }
 
             // acceptDelayedBroadcast
-            const acceptDelayedBroadcastFlag = paramsReader.readInt8()
+            const acceptDelayedBroadcastFlag = paramsReader.readInt8();
             if (acceptDelayedBroadcastFlag === -1) {
-              args.options.acceptDelayedBroadcast = undefined
+              args.options.acceptDelayedBroadcast = undefined;
             } else {
-              args.options.acceptDelayedBroadcast = acceptDelayedBroadcastFlag === 1
+              args.options.acceptDelayedBroadcast =
+                acceptDelayedBroadcastFlag === 1;
             }
 
             // trustSelf
-            const trustSelfFlag = paramsReader.readInt8()
+            const trustSelfFlag = paramsReader.readInt8();
             if (trustSelfFlag === -1) {
-              args.options.trustSelf = undefined
+              args.options.trustSelf = undefined;
             } else if (trustSelfFlag === 1) {
-              args.options.trustSelf = 'known'
+              args.options.trustSelf = "known";
             }
 
             // knownTxids
-            const knownTxidsLength = paramsReader.readVarIntNum()
+            const knownTxidsLength = paramsReader.readVarIntNum();
             if (knownTxidsLength >= 0) {
-              args.options.knownTxids = []
+              args.options.knownTxids = [];
               for (let i = 0; i < knownTxidsLength; i++) {
-                const txidBytes = paramsReader.read(32)
-                const txid = Utils.toHex(txidBytes)
-                args.options.knownTxids.push(txid)
+                const txidBytes = paramsReader.read(32);
+                const txid = Utils.toHex(txidBytes);
+                args.options.knownTxids.push(txid);
               }
             } else {
-              args.options.knownTxids = undefined
+              args.options.knownTxids = undefined;
             }
 
             // returnTXIDOnly
-            const returnTXIDOnlyFlag = paramsReader.readInt8()
+            const returnTXIDOnlyFlag = paramsReader.readInt8();
             if (returnTXIDOnlyFlag === -1) {
-              args.options.returnTXIDOnly = undefined
+              args.options.returnTXIDOnly = undefined;
             } else {
-              args.options.returnTXIDOnly = returnTXIDOnlyFlag === 1
+              args.options.returnTXIDOnly = returnTXIDOnlyFlag === 1;
             }
 
             // noSend
-            const noSendFlag = paramsReader.readInt8()
+            const noSendFlag = paramsReader.readInt8();
             if (noSendFlag === -1) {
-              args.options.noSend = undefined
+              args.options.noSend = undefined;
             } else {
-              args.options.noSend = noSendFlag === 1
+              args.options.noSend = noSendFlag === 1;
             }
 
             // noSendChange
-            const noSendChangeLength = paramsReader.readVarIntNum()
+            const noSendChangeLength = paramsReader.readVarIntNum();
             if (noSendChangeLength >= 0) {
-              args.options.noSendChange = []
+              args.options.noSendChange = [];
               for (let i = 0; i < noSendChangeLength; i++) {
-                const outpoint = this.decodeOutpoint(paramsReader)
-                args.options.noSendChange.push(outpoint)
+                const outpoint = this.decodeOutpoint(paramsReader);
+                args.options.noSendChange.push(outpoint);
               }
             } else {
-              args.options.noSendChange = undefined
+              args.options.noSendChange = undefined;
             }
 
             // sendWith
-            const sendWithLength = paramsReader.readVarIntNum()
+            const sendWithLength = paramsReader.readVarIntNum();
             if (sendWithLength >= 0) {
-              args.options.sendWith = []
+              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)
+                const txidBytes = paramsReader.read(32);
+                const txid = Utils.toHex(txidBytes);
+                args.options.sendWith.push(txid);
               }
             } else {
-              args.options.sendWith = undefined
+              args.options.sendWith = undefined;
             }
 
             // randomizeOutputs
-            const randomizeOutputsFlag = paramsReader.readInt8()
+            const randomizeOutputsFlag = paramsReader.readInt8();
             if (randomizeOutputsFlag === -1) {
-              args.options.randomizeOutputs = undefined
+              args.options.randomizeOutputs = undefined;
             } else {
-              args.options.randomizeOutputs = randomizeOutputsFlag === 1
+              args.options.randomizeOutputs = randomizeOutputsFlag === 1;
             }
           } else {
-            args.options = undefined
+            args.options = undefined;
           }
 
           // 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()
+          const resultWriter = new Utils.Writer();
 
           // txid
           if (createActionResult.txid) {
-            resultWriter.writeInt8(1)
-            resultWriter.write(Utils.toArray(createActionResult.txid, 'hex'))
+            resultWriter.writeInt8(1);
+            resultWriter.write(Utils.toArray(createActionResult.txid, "hex"));
           } else {
-            resultWriter.writeInt8(0)
+            resultWriter.writeInt8(0);
           }
 
           // tx
           if (createActionResult.tx) {
-            resultWriter.writeInt8(1)
-            resultWriter.writeVarIntNum(createActionResult.tx.length)
-            resultWriter.write(createActionResult.tx)
+            resultWriter.writeInt8(1);
+            resultWriter.writeVarIntNum(createActionResult.tx.length);
+            resultWriter.write(createActionResult.tx);
           } else {
-            resultWriter.writeInt8(0)
+            resultWriter.writeInt8(0);
           }
 
           // noSendChange
           if (createActionResult.noSendChange) {
-            resultWriter.writeVarIntNum(createActionResult.noSendChange.length)
+            resultWriter.writeVarIntNum(createActionResult.noSendChange.length);
             for (const outpoint of createActionResult.noSendChange) {
-              resultWriter.write(this.encodeOutpoint(outpoint))
+              resultWriter.write(this.encodeOutpoint(outpoint));
             }
           } else {
-            resultWriter.writeVarIntNum(-1)
+            resultWriter.writeVarIntNum(-1);
           }
 
           // sendWithResults
           if (createActionResult.sendWithResults) {
-            resultWriter.writeVarIntNum(createActionResult.sendWithResults.length)
+            resultWriter.writeVarIntNum(
+              createActionResult.sendWithResults.length
+            );
             for (const result of createActionResult.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)
+              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)
+            resultWriter.writeVarIntNum(-1);
           }
 
           // signableTransaction
           if (createActionResult.signableTransaction) {
-            resultWriter.writeInt8(1)
-            resultWriter.writeVarIntNum(createActionResult.signableTransaction.tx.length)
-            resultWriter.write(createActionResult.signableTransaction.tx)
-            const referenceBytes = Utils.toArray(createActionResult.signableTransaction.reference, 'base64')
-            resultWriter.writeVarIntNum(referenceBytes.length)
-            resultWriter.write(referenceBytes)
+            resultWriter.writeInt8(1);
+            resultWriter.writeVarIntNum(
+              createActionResult.signableTransaction.tx.length
+            );
+            resultWriter.write(createActionResult.signableTransaction.tx);
+            const referenceBytes = Utils.toArray(
+              createActionResult.signableTransaction.reference,
+              "base64"
+            );
+            resultWriter.writeVarIntNum(referenceBytes.length);
+            resultWriter.write(referenceBytes);
           } else {
-            resultWriter.writeInt8(0)
+            resultWriter.writeInt8(0);
           }
 
           // Return success code and result
-          const responseWriter = new Utils.Writer()
-          responseWriter.writeUInt8(0) // errorByte = 0
-          responseWriter.write(resultWriter.toArray())
-          return responseWriter.toArray()
-
-        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
-              }
-
-              args.spends[inputIndex] = spend
+          const responseWriter = new Utils.Writer();
+          responseWriter.writeUInt8(0); // errorByte = 0
+          responseWriter.write(resultWriter.toArray());
+          return responseWriter.toArray();
+
+        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 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 = {}
+            args.spends[inputIndex] = spend;
+          }
 
-              // acceptDelayedBroadcast
-              const acceptDelayedBroadcastFlag = paramsReader.readInt8()
-              if (acceptDelayedBroadcastFlag === -1) {
-                args.options.acceptDelayedBroadcast = undefined
-              } else {
-                args.options.acceptDelayedBroadcast = acceptDelayedBroadcastFlag === 1
-              }
+          // Deserialize reference
+          const referenceLength = paramsReader.readVarIntNum();
+          const referenceBytes = paramsReader.read(referenceLength);
+          args.reference = Utils.toBase64(referenceBytes);
 
-              // returnTXIDOnly
-              const returnTXIDOnlyFlag = paramsReader.readInt8()
-              if (returnTXIDOnlyFlag === -1) {
-                args.options.returnTXIDOnly = undefined
-              } else {
-                args.options.returnTXIDOnly = returnTXIDOnlyFlag === 1
-              }
-
-              // 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)
-            }
-
-            // 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)
-
-            // Call the method
-            await this.wallet.abortAction({ reference }, originator)
-
-            // 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))
+              args.options.sendWith = undefined;
             }
+          } else {
+            args.options = undefined;
+          }
 
-            // 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'
-            }
+          // Call the method
+          const signActionResult = await this.wallet.signAction(
+            args,
+            originator
+          );
 
-            // 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
-              }
-            }
+          // Serialize the result
+          const resultWriter = new Utils.Writer();
 
-            // Deserialize limit
-            const limit = paramsReader.readVarIntNum()
-            if (limit >= 0) {
-              args.limit = limit
-            } else {
-              args.limit = undefined
-            }
+          // txid
+          if (signActionResult.txid) {
+            resultWriter.writeInt8(1);
+            resultWriter.write(Utils.toArray(signActionResult.txid, "hex"));
+          } else {
+            resultWriter.writeInt8(0);
+          }
 
-            // Deserialize offset
-            const offset = paramsReader.readVarIntNum()
-            if (offset >= 0) {
-              args.offset = offset
-            } else {
-              args.offset = undefined
-            }
+          // tx
+          if (signActionResult.tx) {
+            resultWriter.writeInt8(1);
+            resultWriter.writeVarIntNum(signActionResult.tx.length);
+            resultWriter.write(signActionResult.tx);
+          } else {
+            resultWriter.writeInt8(0);
+          }
 
-            // Deserialize seekPermission
-            const seekPermission = paramsReader.readInt8()
-            if (seekPermission >= 0) {
-              args.seekPermission = seekPermission === 1
-            } else {
-              args.seekPermission = undefined
+          // 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);
             }
+          } else {
+            resultWriter.writeVarIntNum(-1);
+          }
 
-            // Call the method
-            const listActionsResult = await this.wallet.listActions(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
+          responseWriter.write(resultWriter.toArray());
+          return responseWriter.toArray();
+        }
+        case "abortAction": {
+          // Deserialize reference
+          const referenceBytes = paramsReader.read();
+          const reference = Utils.toBase64(referenceBytes);
 
-            // totalActions
-            resultWriter.writeVarIntNum(listActionsResult.totalActions)
+          // Call the method
+          await this.wallet.abortAction({ reference }, originator);
 
-            // actions
-            for (const action of listActionsResult.actions) {
-              // txid
-              resultWriter.write(Utils.toArray(action.txid, 'hex'))
+          // 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));
+          }
 
-              // 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)
-              }
+          // 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";
+          }
 
-              // 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)
-                  }
+          // 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;
+            }
+          }
 
-                  // unlockingScript
-                  if (input.unlockingScript !== undefined) {
-                    const unlockingScriptBytes = Utils.toArray(input.unlockingScript, 'hex')
-                    resultWriter.writeVarIntNum(unlockingScriptBytes.length)
-                    resultWriter.write(unlockingScriptBytes)
-                  } else {
-                    resultWriter.writeVarIntNum(-1)
-                  }
+          // Deserialize limit
+          const limit = paramsReader.readVarIntNum();
+          if (limit >= 0) {
+            args.limit = limit;
+          } else {
+            args.limit = undefined;
+          }
 
-                  // inputDescription
-                  const inputDescriptionBytes = Utils.toArray(input.inputDescription, 'utf8')
-                  resultWriter.writeVarIntNum(inputDescriptionBytes.length)
-                  resultWriter.write(inputDescriptionBytes)
+          // Deserialize offset
+          const offset = paramsReader.readVarIntNum();
+          if (offset >= 0) {
+            args.offset = offset;
+          } else {
+            args.offset = undefined;
+          }
 
-                  // sequenceNumber
-                  resultWriter.writeVarIntNum(input.sequenceNumber)
-                }
-              } else {
-                resultWriter.writeVarIntNum(-1)
-              }
+          // Deserialize seekPermission
+          const seekPermission = paramsReader.readInt8();
+          if (seekPermission >= 0) {
+            args.seekPermission = seekPermission === 1;
+          } else {
+            args.seekPermission = undefined;
+          }
 
-              // 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)
-                  }
+          // Call the method
+          const listActionsResult = await this.wallet.listActions(
+            args,
+            originator
+          );
 
-                  // 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)
-                  }
+          // Serialize the result
+          const resultWriter = new Utils.Writer();
 
-                  // 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)
-                  }
+          // totalActions
+          resultWriter.writeVarIntNum(listActionsResult.totalActions);
 
-                  // 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)
+          // 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);
             }
 
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            responseWriter.write(resultWriter.toArray())
-            return responseWriter.toArray()
-          }
-        case 'internalizeAction':
-          {
-            const args: any = {}
+            // version
+            resultWriter.writeVarIntNum(action.version);
 
-            // Read tx
-            const txLength = paramsReader.readVarIntNum()
-            args.tx = paramsReader.read(txLength)
+            // lockTime
+            resultWriter.writeVarIntNum(action.lockTime);
 
-            // 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)
-
-                // derivationPrefix
-                const derivationPrefixLength = paramsReader.readVarIntNum()
-                const derivationPrefixBytes = paramsReader.read(derivationPrefixLength)
-                output.paymentRemittance.derivationPrefix = Utils.toBase64(derivationPrefixBytes)
-
-                // 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 = {}
+            // inputs
+            if (action.inputs !== undefined) {
+              resultWriter.writeVarIntNum(action.inputs.length);
+              for (const input of action.inputs) {
+                // sourceOutpoint
+                resultWriter.write(this.encodeOutpoint(input.sourceOutpoint));
 
-                // basket
-                const basketLength = paramsReader.readVarIntNum()
-                const basketBytes = paramsReader.read(basketLength)
-                output.insertionRemittance.basket = Utils.toUTF8(basketBytes)
+                // sourceSatoshis
+                resultWriter.writeVarIntNum(input.sourceSatoshis);
 
-                // customInstructions
-                const customInstructionsLength = paramsReader.readVarIntNum()
-                if (customInstructionsLength >= 0) {
-                  const customInstructionsBytes = paramsReader.read(customInstructionsLength)
-                  output.insertionRemittance.customInstructions = Utils.toUTF8(customInstructionsBytes)
+                // sourceLockingScript
+                if (input.sourceLockingScript !== undefined) {
+                  const sourceLockingScriptBytes = Utils.toArray(
+                    input.sourceLockingScript,
+                    "hex"
+                  );
+                  resultWriter.writeVarIntNum(sourceLockingScriptBytes.length);
+                  resultWriter.write(sourceLockingScriptBytes);
+                } 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))
-                  }
+                // unlockingScript
+                if (input.unlockingScript !== undefined) {
+                  const unlockingScriptBytes = Utils.toArray(
+                    input.unlockingScript,
+                    "hex"
+                  );
+                  resultWriter.writeVarIntNum(unlockingScriptBytes.length);
+                  resultWriter.write(unlockingScriptBytes);
                 } 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)))
-              }
-            }
-
-            const descriptionLength = paramsReader.readVarIntNum()
-            args.description = Utils.toUTF8(paramsReader.read(descriptionLength))
-
-            // Deserialize seekPermission
-            const seekPermission = paramsReader.readInt8()
-            if (seekPermission >= 0) {
-              args.seekPermission = seekPermission === 1
-            } else {
-              args.seekPermission = undefined
-            }
 
-            // Call the method
-            await this.wallet.internalizeAction(args, originator)
+                // inputDescription
+                const inputDescriptionBytes = Utils.toArray(
+                  input.inputDescription,
+                  "utf8"
+                );
+                resultWriter.writeVarIntNum(inputDescriptionBytes.length);
+                resultWriter.write(inputDescriptionBytes);
 
-            // Return success code and result
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            return responseWriter.toArray()
-          }
-
-        case 'listOutputs':
-          {
-            const args: any = {}
-
-            // Deserialize basket
-            const basketLength = paramsReader.readVarIntNum()
-            const basketBytes = paramsReader.read(basketLength)
-            args.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))
+                // sequenceNumber
+                resultWriter.writeVarIntNum(input.sequenceNumber);
               }
             } 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
-            }
-
-            // 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
+              resultWriter.writeVarIntNum(-1);
             }
 
-            // Deserialize includeCustomInstructions
-            const includeCustomInstructionsFlag = paramsReader.readInt8()
-            if (includeCustomInstructionsFlag === -1) {
-              args.includeCustomInstructions = undefined
-            } else {
-              args.includeCustomInstructions = includeCustomInstructionsFlag === 1
-            }
+            // 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);
+                }
 
-            // Deserialize includeTags
-            const includeTagsFlag = paramsReader.readInt8()
-            if (includeTagsFlag === -1) {
-              args.includeTags = undefined
-            } else {
-              args.includeTags = includeTagsFlag === 1
-            }
+                // spendable
+                resultWriter.writeInt8(output.spendable ? 1 : 0);
 
-            // Deserialize includeLabels
-            const includeLabelsFlag = paramsReader.readInt8()
-            if (includeLabelsFlag === -1) {
-              args.includeLabels = undefined
-            } else {
-              args.includeLabels = includeLabelsFlag === 1
-            }
+                // outputDescription
+                const outputDescriptionBytes = Utils.toArray(
+                  output.outputDescription,
+                  "utf8"
+                );
+                resultWriter.writeVarIntNum(outputDescriptionBytes.length);
+                resultWriter.write(outputDescriptionBytes);
 
-            // Deserialize limit
-            const limit = paramsReader.readVarIntNum()
-            if (limit >= 0) {
-              args.limit = limit
-            } else {
-              args.limit = undefined
-            }
+                // basket
+                if (output.basket !== undefined) {
+                  const basketBytes = Utils.toArray(output.basket, "utf8");
+                  resultWriter.writeVarIntNum(basketBytes.length);
+                  resultWriter.write(basketBytes);
+                } else {
+                  resultWriter.writeVarIntNum(-1);
+                }
 
-            // Deserialize offset
-            const offset = paramsReader.readVarIntNum()
-            if (offset >= 0) {
-              args.offset = offset
-            } else {
-              args.offset = 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
+                // customInstructions
+                if (output.customInstructions !== undefined) {
+                  const customInstructionsBytes = Utils.toArray(
+                    output.customInstructions,
+                    "utf8"
+                  );
+                  resultWriter.writeVarIntNum(customInstructionsBytes.length);
+                  resultWriter.write(customInstructionsBytes);
+                } else {
+                  resultWriter.writeVarIntNum(-1);
+                }
+              }
             } else {
-              args.seekPermission = undefined
+              resultWriter.writeVarIntNum(-1);
             }
+          }
 
-            // Call the method
-            const listOutputsResult = await this.wallet.listOutputs(args, originator)
-
-            // Serialize the result
-            const resultWriter = new Utils.Writer()
-
-            // totalOutputs
-            resultWriter.writeVarIntNum(listOutputsResult.totalOutputs)
-
-            // BEEF length and BEEF or -1
-            if (listOutputsResult.BEEF) {
-              resultWriter.writeVarIntNum(listOutputsResult.BEEF.length)
-              resultWriter.write(listOutputsResult.BEEF)
-            } 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 = {};
 
-            // outputs
-            for (const output of listOutputsResult.outputs) {
-              // outpoint
-              resultWriter.write(this.encodeOutpoint(output.outpoint))
+          // Read tx
+          const txLength = paramsReader.readVarIntNum();
+          args.tx = paramsReader.read(txLength);
 
-              // satoshis
-              resultWriter.writeVarIntNum(output.satoshis)
+          // 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
+              );
+
+              // derivationPrefix
+              const derivationPrefixLength = paramsReader.readVarIntNum();
+              const derivationPrefixBytes = paramsReader.read(
+                derivationPrefixLength
+              );
+              output.paymentRemittance.derivationPrefix = Utils.toBase64(
+                derivationPrefixBytes
+              );
+
+              // 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 = {};
 
-              // lockingScript
-              if (output.lockingScript !== undefined) {
-                const lockingScriptBytes = Utils.toArray(output.lockingScript, 'hex')
-                resultWriter.writeVarIntNum(lockingScriptBytes.length)
-                resultWriter.write(lockingScriptBytes)
-              } else {
-                resultWriter.writeVarIntNum(-1)
-              }
+              // basket
+              const basketLength = paramsReader.readVarIntNum();
+              const basketBytes = paramsReader.read(basketLength);
+              output.insertionRemittance.basket = Utils.toUTF8(basketBytes);
 
               // customInstructions
-              if (output.customInstructions !== undefined) {
-                const customInstructionsBytes = Utils.toArray(output.customInstructions, 'utf8')
-                resultWriter.writeVarIntNum(customInstructionsBytes.length)
-                resultWriter.write(customInstructionsBytes)
-              } else {
-                resultWriter.writeVarIntNum(-1)
+              const customInstructionsLength = paramsReader.readVarIntNum();
+              if (customInstructionsLength >= 0) {
+                const customInstructionsBytes = paramsReader.read(
+                  customInstructionsLength
+                );
+                output.insertionRemittance.customInstructions = Utils.toUTF8(
+                  customInstructionsBytes
+                );
               }
 
               // 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)
+              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 {
-                resultWriter.writeVarIntNum(-1)
+                output.insertionRemittance.tags = [];
               }
             }
 
-            // Return success code and result
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            responseWriter.write(resultWriter.toArray())
-            return responseWriter.toArray()
+            args.outputs.push(output);
           }
 
-        case 'relinquishOutput':
-          {
-            const args: any = {}
+          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 basket
-            const basketLength = paramsReader.readVarIntNum()
-            const basketBytes = paramsReader.read(basketLength)
-            args.basket = Utils.toUTF8(basketBytes)
+          const descriptionLength = paramsReader.readVarIntNum();
+          args.description = Utils.toUTF8(paramsReader.read(descriptionLength));
 
-            // 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
+          await this.wallet.internalizeAction(args, originator);
 
-            // Return success code and result
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            return responseWriter.toArray()
+          // Return success code and result
+          const responseWriter = new Utils.Writer();
+          responseWriter.writeUInt8(0); // errorByte = 0
+          return responseWriter.toArray();
+        }
+
+        case "listOutputs": {
+          const args: any = {};
+
+          // Deserialize basket
+          const basketLength = paramsReader.readVarIntNum();
+          const basketBytes = paramsReader.read(basketLength);
+          args.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));
+            }
+          } else {
+            args.tags = undefined;
           }
 
-        case 'getPublicKey':
-          {
-            const args: any = {}
+          // Deserialize tagQueryMode
+          const tagQueryModeFlag = paramsReader.readInt8();
+          if (tagQueryModeFlag === 1) {
+            args.tagQueryMode = "all";
+          } else if (tagQueryModeFlag === 2) {
+            args.tagQueryMode = "any";
+          } else {
+            args.tagQueryMode = undefined;
+          }
 
-            // Deserialize identityKey flag
-            const identityKeyFlag = paramsReader.readUInt8()
-            args.identityKey = identityKeyFlag === 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;
+          }
 
-            if (!args.identityKey) {
-              // Deserialize protocolID
-              args.protocolID = this.decodeProtocolID(paramsReader)
+          // Deserialize includeCustomInstructions
+          const includeCustomInstructionsFlag = paramsReader.readInt8();
+          if (includeCustomInstructionsFlag === -1) {
+            args.includeCustomInstructions = undefined;
+          } else {
+            args.includeCustomInstructions =
+              includeCustomInstructionsFlag === 1;
+          }
 
-              // Deserialize keyID
-              args.keyID = this.decodeString(paramsReader)
+          // Deserialize includeTags
+          const includeTagsFlag = paramsReader.readInt8();
+          if (includeTagsFlag === -1) {
+            args.includeTags = undefined;
+          } else {
+            args.includeTags = includeTagsFlag === 1;
+          }
 
-              // Deserialize counterparty
-              args.counterparty = this.decodeCounterparty(paramsReader)
+          // Deserialize includeLabels
+          const includeLabelsFlag = paramsReader.readInt8();
+          if (includeLabelsFlag === -1) {
+            args.includeLabels = undefined;
+          } else {
+            args.includeLabels = includeLabelsFlag === 1;
+          }
 
-              // Deserialize privilege parameters
-              const privilegedFlag = paramsReader.readInt8()
-              if (privilegedFlag === -1) {
-                args.privileged = undefined
-              } else {
-                args.privileged = privilegedFlag === 1
-              }
+          // Deserialize limit
+          const limit = paramsReader.readVarIntNum();
+          if (limit >= 0) {
+            args.limit = limit;
+          } else {
+            args.limit = undefined;
+          }
 
-              const privilegedReasonLength = paramsReader.readInt8()
-              if (privilegedReasonLength !== -1) {
-                const privilegedReasonBytes = paramsReader.read(privilegedReasonLength)
-                args.privilegedReason = Utils.toUTF8(privilegedReasonBytes)
-              } else {
-                args.privilegedReason = undefined
-              }
+          // Deserialize offset
+          const offset = paramsReader.readVarIntNum();
+          if (offset >= 0) {
+            args.offset = offset;
+          } else {
+            args.offset = 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
-              }
+          // Deserialize seekPermission
+          const seekPermission = paramsReader.readInt8();
+          if (seekPermission >= 0) {
+            args.seekPermission = seekPermission === 1;
+          } else {
+            args.seekPermission = undefined;
+          }
 
-              const privilegedReasonLength = paramsReader.readInt8()
-              if (privilegedReasonLength !== -1) {
-                const privilegedReasonBytes = paramsReader.read(privilegedReasonLength)
-                args.privilegedReason = Utils.toUTF8(privilegedReasonBytes)
-              } else {
-                args.privilegedReason = undefined
-              }
-            }
+          // Call the method
+          const listOutputsResult = await this.wallet.listOutputs(
+            args,
+            originator
+          );
 
-            // Deserialize seekPermission
-            const seekPermission = paramsReader.readInt8()
-            if (seekPermission >= 0) {
-              args.seekPermission = seekPermission === 1
-            } else {
-              args.seekPermission = undefined
-            }
+          // Serialize the result
+          const resultWriter = new Utils.Writer();
 
-            // Call the method
-            const getPublicKeyResult = await this.wallet.getPublicKey(args, originator)
+          // totalOutputs
+          resultWriter.writeVarIntNum(listOutputsResult.totalOutputs);
 
-            // 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()
+          // BEEF length and BEEF or -1
+          if (listOutputsResult.BEEF) {
+            resultWriter.writeVarIntNum(listOutputsResult.BEEF.length);
+            resultWriter.write(listOutputsResult.BEEF);
+          } else {
+            resultWriter.writeVarIntNum(-1);
           }
 
-        case 'encrypt':
-          {
-            const args: any = this.decodeKeyRelatedParams(paramsReader)
-
-            // Deserialize plaintext
-            const plaintextLength = paramsReader.readVarIntNum()
-            args.plaintext = paramsReader.read(plaintextLength)
-
-            // Deserialize seekPermission
-            const seekPermission = paramsReader.readInt8()
-            if (seekPermission >= 0) {
-              args.seekPermission = seekPermission === 1
+          // outputs
+          for (const output of listOutputsResult.outputs) {
+            // outpoint
+            resultWriter.write(this.encodeOutpoint(output.outpoint));
+
+            // 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 {
-              args.seekPermission = undefined
+              resultWriter.writeVarIntNum(-1);
             }
 
-            // Call the method
-            const encryptResult = await this.wallet.encrypt(args, originator)
-
-            // Serialize the result
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            responseWriter.write(encryptResult.ciphertext)
-            return responseWriter.toArray()
-          }
-
-        case 'decrypt':
-          {
-            const args: any = this.decodeKeyRelatedParams(paramsReader)
-
-            // Deserialize ciphertext
-            const ciphertextLength = paramsReader.readVarIntNum()
-            args.ciphertext = paramsReader.read(ciphertextLength)
-
-            // Deserialize seekPermission
-            const seekPermission = paramsReader.readInt8()
-            if (seekPermission >= 0) {
-              args.seekPermission = seekPermission === 1
+            // customInstructions
+            if (output.customInstructions !== undefined) {
+              const customInstructionsBytes = Utils.toArray(
+                output.customInstructions,
+                "utf8"
+              );
+              resultWriter.writeVarIntNum(customInstructionsBytes.length);
+              resultWriter.write(customInstructionsBytes);
             } else {
-              args.seekPermission = undefined
+              resultWriter.writeVarIntNum(-1);
             }
 
-            // Call the method
-            const decryptResult = await this.wallet.decrypt(args, originator)
+            // 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);
+            }
 
-            // Serialize the result
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            responseWriter.write(decryptResult.plaintext)
-            return responseWriter.toArray()
+            // 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);
+            }
           }
 
-        case 'createHmac':
-          {
-            const args: any = this.decodeKeyRelatedParams(paramsReader)
-
-            // Deserialize data
-            const dataLength = paramsReader.readVarIntNum()
-            args.data = paramsReader.read(dataLength)
+          // Return success code and result
+          const responseWriter = new Utils.Writer();
+          responseWriter.writeUInt8(0); // errorByte = 0
+          responseWriter.write(resultWriter.toArray());
+          return responseWriter.toArray();
+        }
 
-            // Deserialize seekPermission
-            const seekPermission = paramsReader.readInt8()
-            if (seekPermission >= 0) {
-              args.seekPermission = seekPermission === 1
-            } else {
-              args.seekPermission = undefined
-            }
+        case "relinquishOutput": {
+          const args: any = {};
 
-            // Call the method
-            const createHmacResult = await this.wallet.createHmac(args, originator)
+          // Deserialize basket
+          const basketLength = paramsReader.readVarIntNum();
+          const basketBytes = paramsReader.read(basketLength);
+          args.basket = Utils.toUTF8(basketBytes);
 
-            // Serialize the result
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            responseWriter.write(createHmacResult.hmac)
-            return responseWriter.toArray()
-          }
+          // Deserialize outpoint
+          args.output = this.decodeOutpoint(paramsReader);
 
-        case 'verifyHmac':
-          {
-            const args: any = this.decodeKeyRelatedParams(paramsReader)
+          // Call the method
+          await this.wallet.relinquishOutput(args, originator);
 
-            // Deserialize hmac
-            args.hmac = paramsReader.read(32)
+          // Return success code and result
+          const responseWriter = new Utils.Writer();
+          responseWriter.writeUInt8(0); // errorByte = 0
+          return responseWriter.toArray();
+        }
 
-            // Deserialize data
-            const dataLength = paramsReader.readVarIntNum()
-            args.data = paramsReader.read(dataLength)
+        case "getPublicKey": {
+          const args: any = {};
 
-            // Deserialize seekPermission
-            const seekPermission = paramsReader.readInt8()
-            if (seekPermission >= 0) {
-              args.seekPermission = seekPermission === 1
-            } else {
-              args.seekPermission = undefined
-            }
+          // Deserialize identityKey flag
+          const identityKeyFlag = paramsReader.readUInt8();
+          args.identityKey = identityKeyFlag === 1;
 
-            // Call the method
-            await this.wallet.verifyHmac(args, originator)
+          if (!args.identityKey) {
+            // Deserialize protocolID
+            args.protocolID = this.decodeProtocolID(paramsReader);
 
-            // Serialize the result (no data to return)
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            return responseWriter.toArray()
-          }
+            // Deserialize keyID
+            args.keyID = this.decodeString(paramsReader);
 
-        case 'createSignature':
-          {
-            const args: any = this.decodeKeyRelatedParams(paramsReader)
+            // Deserialize counterparty
+            args.counterparty = this.decodeCounterparty(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 privilege parameters
+            const privilegedFlag = paramsReader.readInt8();
+            if (privilegedFlag === -1) {
+              args.privileged = undefined;
+            } else {
+              args.privileged = privilegedFlag === 1;
             }
 
-            // Deserialize seekPermission
-            const seekPermission = paramsReader.readInt8()
-            if (seekPermission >= 0) {
-              args.seekPermission = seekPermission === 1
+            const privilegedReasonLength = paramsReader.readInt8();
+            if (privilegedReasonLength !== -1) {
+              const privilegedReasonBytes = paramsReader.read(
+                privilegedReasonLength
+              );
+              args.privilegedReason = Utils.toUTF8(privilegedReasonBytes);
             } else {
-              args.seekPermission = undefined
+              args.privilegedReason = undefined;
             }
 
-            // Call the method
-            const createSignatureResult = await this.wallet.createSignature(args, 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)
-
             // Deserialize forSelf
-            const forSelfFlag = paramsReader.readInt8()
+            const forSelfFlag = paramsReader.readInt8();
             if (forSelfFlag === -1) {
-              args.forSelf = undefined
+              args.forSelf = undefined;
             } else {
-              args.forSelf = forSelfFlag === 1
+              args.forSelf = forSelfFlag === 1;
             }
-
-            // 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)
+          } else {
+            // Deserialize privilege parameters
+            const privilegedFlag = paramsReader.readInt8();
+            if (privilegedFlag === -1) {
+              args.privileged = undefined;
+            } else {
+              args.privileged = privilegedFlag === 1;
             }
 
-            // Deserialize seekPermission
-            const seekPermission = paramsReader.readInt8()
-            if (seekPermission >= 0) {
-              args.seekPermission = seekPermission === 1
+            const privilegedReasonLength = paramsReader.readInt8();
+            if (privilegedReasonLength !== -1) {
+              const privilegedReasonBytes = paramsReader.read(
+                privilegedReasonLength
+              );
+              args.privilegedReason = Utils.toUTF8(privilegedReasonBytes);
             } else {
-              args.seekPermission = undefined
+              args.privilegedReason = undefined;
             }
-
-            // Call the method
-            await this.wallet.verifySignature(args, originator)
-
-            // Serialize the result (no data to return)
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            return responseWriter.toArray()
           }
 
-        case 'isAuthenticated':
-          {
-            // No parameters to deserialize
+          // Deserialize seekPermission
+          const seekPermission = paramsReader.readInt8();
+          if (seekPermission >= 0) {
+            args.seekPermission = seekPermission === 1;
+          } else {
+            args.seekPermission = undefined;
+          }
 
-            // Call the method
-            const isAuthenticatedResult = await this.wallet.isAuthenticated({}, originator)
+          // Call the method
+          const getPublicKeyResult = await this.wallet.getPublicKey(
+            args,
+            originator
+          );
 
-            // Serialize the result
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            responseWriter.writeUInt8(isAuthenticatedResult.authenticated ? 1 : 0)
-            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 "encrypt": {
+          const args: any = this.decodeKeyRelatedParams(paramsReader);
+
+          // Deserialize plaintext
+          const plaintextLength = paramsReader.readVarIntNum();
+          args.plaintext = paramsReader.read(plaintextLength);
+
+          // 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 encryptResult = await this.wallet.encrypt(args, originator);
+
+          // Serialize the result
+          const responseWriter = new Utils.Writer();
+          responseWriter.writeUInt8(0); // errorByte = 0
+          responseWriter.write(encryptResult.ciphertext);
+          return responseWriter.toArray();
+        }
+
+        case "decrypt": {
+          const args: any = this.decodeKeyRelatedParams(paramsReader);
+
+          // Deserialize ciphertext
+          const ciphertextLength = paramsReader.readVarIntNum();
+          args.ciphertext = paramsReader.read(ciphertextLength);
+
+          // Deserialize seekPermission
+          const seekPermission = paramsReader.readInt8();
+          if (seekPermission >= 0) {
+            args.seekPermission = seekPermission === 1;
+          } else {
+            args.seekPermission = undefined;
+          }
 
-            // Call the method
-            await this.wallet.waitForAuthentication({}, originator)
+          // Call the method
+          const decryptResult = await this.wallet.decrypt(args, originator);
 
-            // Serialize the result (authenticated is always true)
-            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(decryptResult.plaintext);
+          return responseWriter.toArray();
+        }
+
+        case "createHmac": {
+          const args: any = this.decodeKeyRelatedParams(paramsReader);
+
+          // Deserialize data
+          const dataLength = paramsReader.readVarIntNum();
+          args.data = paramsReader.read(dataLength);
+
+          // Deserialize seekPermission
+          const seekPermission = paramsReader.readInt8();
+          if (seekPermission >= 0) {
+            args.seekPermission = seekPermission === 1;
+          } else {
+            args.seekPermission = undefined;
           }
 
-        case 'getHeight':
-          {
-            // No parameters to deserialize
+          // Call the method
+          const createHmacResult = await this.wallet.createHmac(
+            args,
+            originator
+          );
+
+          // Serialize the result
+          const responseWriter = new Utils.Writer();
+          responseWriter.writeUInt8(0); // errorByte = 0
+          responseWriter.write(createHmacResult.hmac);
+          return responseWriter.toArray();
+        }
+
+        case "verifyHmac": {
+          const args: any = this.decodeKeyRelatedParams(paramsReader);
+
+          // Deserialize hmac
+          args.hmac = paramsReader.read(32);
+
+          // Deserialize data
+          const dataLength = paramsReader.readVarIntNum();
+          args.data = paramsReader.read(dataLength);
+
+          // Deserialize seekPermission
+          const seekPermission = paramsReader.readInt8();
+          if (seekPermission >= 0) {
+            args.seekPermission = seekPermission === 1;
+          } else {
+            args.seekPermission = undefined;
+          }
 
-            // Call the method
-            const getHeightResult = await this.wallet.getHeight({}, originator)
+          // Call the method
+          await this.wallet.verifyHmac(args, originator);
+
+          // Serialize the result (no data to return)
+          const responseWriter = new Utils.Writer();
+          responseWriter.writeUInt8(0); // errorByte = 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);
+          }
 
-            // 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
+          const createSignatureResult = await this.wallet.createSignature(
+            args,
+            originator
+          );
 
-            // Deserialize height
-            args.height = paramsReader.readVarIntNum()
+          // 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);
+
+          // Deserialize forSelf
+          const forSelfFlag = paramsReader.readInt8();
+          if (forSelfFlag === -1) {
+            args.forSelf = undefined;
+          } else {
+            args.forSelf = forSelfFlag === 1;
+          }
 
-            // Call the method
-            const getHeaderResult = await this.wallet.getHeaderForHeight(args, originator)
+          // 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);
+          }
 
-            // 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()
+          // Deserialize seekPermission
+          const seekPermission = paramsReader.readInt8();
+          if (seekPermission >= 0) {
+            args.seekPermission = seekPermission === 1;
+          } else {
+            args.seekPermission = undefined;
           }
 
-        case 'getNetwork':
-          {
-            // No parameters to deserialize
+          // Call the method
+          await this.wallet.verifySignature(args, originator);
 
-            // Call the method
-            const getNetworkResult = await this.wallet.getNetwork({}, 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(getNetworkResult.network === 'mainnet' ? 0 : 1)
-            return responseWriter.toArray()
-          }
+        case "isAuthenticated": {
+          // No parameters to deserialize
 
-        case 'getVersion':
-          {
-            // No parameters to deserialize
+          // Call the method
+          const isAuthenticatedResult = await this.wallet.isAuthenticated(
+            {},
+            originator
+          );
 
-            // Call the method
-            const getVersionResult = await this.wallet.getVersion({}, originator)
+          // Serialize the result
+          const responseWriter = new Utils.Writer();
+          responseWriter.writeUInt8(0); // errorByte = 0
+          responseWriter.writeUInt8(
+            isAuthenticatedResult.authenticated ? 1 : 0
+          );
+          return responseWriter.toArray();
+        }
 
-            // 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()
-          }
+        case "waitForAuthentication": {
+          // No parameters to deserialize
 
-        case 'revealCounterpartyKeyLinkage':
-          {
-            const args: any = {}
+          // Call the method
+          await this.wallet.waitForAuthentication({}, originator);
 
-            // Read privileged parameters
-            const privilegedFlag = paramsReader.readInt8()
-            if (privilegedFlag === -1) {
-              args.privileged = undefined
-            } else {
-              args.privileged = privilegedFlag === 1
-            }
+          // Serialize the result (authenticated is always true)
+          const responseWriter = new Utils.Writer();
+          responseWriter.writeUInt8(0); // errorByte = 0
+          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 "getHeight": {
+          // No parameters to deserialize
+
+          // Call the method
+          const getHeightResult = await this.wallet.getHeight({}, originator);
 
-            // Read counterparty public key
-            const counterpartyBytes = paramsReader.read(33)
-            args.counterparty = Utils.toHex(counterpartyBytes)
+          // Serialize the result
+          const responseWriter = new Utils.Writer();
+          responseWriter.writeUInt8(0); // errorByte = 0
+          responseWriter.writeVarIntNum(getHeightResult.height);
+          return responseWriter.toArray();
+        }
 
-            // Read verifier public key
-            const verifierBytes = paramsReader.read(33)
-            args.verifier = Utils.toHex(verifierBytes)
+        case "getHeaderForHeight": {
+          const args: any = {};
 
-            // Call the method
-            const revealResult = await this.wallet.revealCounterpartyKeyLinkage(args, originator)
+          // Deserialize height
+          args.height = paramsReader.readVarIntNum();
 
-            // Serialize the result
-            const resultWriter = new Utils.Writer()
+          // Call the method
+          const getHeaderResult = await this.wallet.getHeaderForHeight(
+            args,
+            originator
+          );
 
-            // Write prover
-            resultWriter.write(Utils.toArray(revealResult.prover, 'hex'))
+          // 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();
+        }
 
-            // Write verifier
-            resultWriter.write(Utils.toArray(revealResult.verifier, 'hex'))
+        case "getNetwork": {
+          // No parameters to deserialize
 
-            // Write counterparty
-            resultWriter.write(Utils.toArray(revealResult.counterparty, 'hex'))
+          // Call the method
+          const getNetworkResult = await this.wallet.getNetwork({}, 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
+          responseWriter.writeUInt8(
+            getNetworkResult.network === "mainnet" ? 0 : 1
+          );
+          return responseWriter.toArray();
+        }
 
-            // Write encryptedLinkage
-            resultWriter.writeVarIntNum(revealResult.encryptedLinkage.length)
-            resultWriter.write(revealResult.encryptedLinkage)
+        case "getVersion": {
+          // No parameters to deserialize
 
-            // Write encryptedLinkageProof
-            resultWriter.writeVarIntNum(revealResult.encryptedLinkageProof.length)
-            resultWriter.write(revealResult.encryptedLinkageProof)
+          // Call the method
+          const getVersionResult = await this.wallet.getVersion({}, 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 versionBytes = Utils.toArray(getVersionResult.version, "utf8");
+          responseWriter.write(versionBytes);
+          return responseWriter.toArray();
+        }
+
+        case "revealCounterpartyKeyLinkage": {
+          const args: any = {};
+
+          // Read privileged parameters
+          const privilegedFlag = paramsReader.readInt8();
+          if (privilegedFlag === -1) {
+            args.privileged = undefined;
+          } else {
+            args.privileged = privilegedFlag === 1;
           }
 
-        case 'revealSpecificKeyLinkage':
-          {
-            // Deserialize key-related parameters and privileged parameters
-            const args = this.decodeKeyRelatedParams(paramsReader)
-
-            // Read verifier public key
-            const verifierBytes = paramsReader.read(33)
-            args.verifier = Utils.toHex(verifierBytes)
+          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 revealResult = await this.wallet.revealSpecificKeyLinkage(args, originator)
+          // Read counterparty public key
+          const counterpartyBytes = paramsReader.read(33);
+          args.counterparty = Utils.toHex(counterpartyBytes);
 
-            // Serialize the result
-            const resultWriter = new Utils.Writer()
+          // Read verifier public key
+          const verifierBytes = paramsReader.read(33);
+          args.verifier = Utils.toHex(verifierBytes);
 
-            // Write prover
-            resultWriter.write(Utils.toArray(revealResult.prover, 'hex'))
+          // Call the method
+          const revealResult = await this.wallet.revealCounterpartyKeyLinkage(
+            args,
+            originator
+          );
 
-            // Write verifier
-            resultWriter.write(Utils.toArray(revealResult.verifier, 'hex'))
+          // Serialize the result
+          const resultWriter = new Utils.Writer();
 
-            // Write counterparty
-            resultWriter.write(Utils.toArray(revealResult.counterparty, 'hex'))
+          // Write prover
+          resultWriter.write(Utils.toArray(revealResult.prover, "hex"));
 
-            // Write securityLevel
-            resultWriter.writeUInt8(revealResult.protocolID[0])
+          // Write verifier
+          resultWriter.write(Utils.toArray(revealResult.verifier, "hex"));
 
-            // Write protocol string
-            const protocolBytesOut = Utils.toArray(revealResult.protocolID[1], 'utf8')
-            resultWriter.writeVarIntNum(protocolBytesOut.length)
-            resultWriter.write(protocolBytesOut)
+          // Write counterparty
+          resultWriter.write(Utils.toArray(revealResult.counterparty, "hex"));
 
-            // Write keyID
-            const keyIDBytesOut = Utils.toArray(revealResult.keyID, 'utf8')
-            resultWriter.writeVarIntNum(keyIDBytesOut.length)
-            resultWriter.write(keyIDBytesOut)
+          // Write revelationTime
+          const revelationTimeBytes = Utils.toArray(
+            revealResult.revelationTime,
+            "utf8"
+          );
+          resultWriter.writeVarIntNum(revelationTimeBytes.length);
+          resultWriter.write(revelationTimeBytes);
 
-            // Write encryptedLinkage
-            resultWriter.writeVarIntNum(revealResult.encryptedLinkage.length)
-            resultWriter.write(revealResult.encryptedLinkage)
+          // Write encryptedLinkage
+          resultWriter.writeVarIntNum(revealResult.encryptedLinkage.length);
+          resultWriter.write(revealResult.encryptedLinkage);
 
-            // Write encryptedLinkageProof
-            resultWriter.writeVarIntNum(revealResult.encryptedLinkageProof.length)
-            resultWriter.write(revealResult.encryptedLinkageProof)
+          // Write encryptedLinkageProof
+          resultWriter.writeVarIntNum(
+            revealResult.encryptedLinkageProof.length
+          );
+          resultWriter.write(revealResult.encryptedLinkageProof);
 
-            // Write proofType
-            resultWriter.writeUInt8(revealResult.proofType)
+          // Return success code and result
+          const responseWriter = new Utils.Writer();
+          responseWriter.writeUInt8(0); // errorByte = 0
+          responseWriter.write(resultWriter.toArray());
+          return responseWriter.toArray();
+        }
 
-            // Return success code and result
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            responseWriter.write(resultWriter.toArray())
-            return responseWriter.toArray()
-          }
+        case "revealSpecificKeyLinkage": {
+          // Deserialize key-related parameters and privileged parameters
+          const args = this.decodeKeyRelatedParams(paramsReader);
 
-        case 'acquireCertificate':
-          {
-            const args: any = {}
+          // Read verifier public key
+          const verifierBytes = paramsReader.read(33);
+          args.verifier = Utils.toHex(verifierBytes);
 
-            // Read args.type
-            const typeBytes = paramsReader.read(32)
-            args.type = Utils.toBase64(typeBytes)
+          // Call the method
+          const revealResult = await this.wallet.revealSpecificKeyLinkage(
+            args,
+            originator
+          );
 
-            // args.certifier
-            const certifierBytes = paramsReader.read(33)
-            args.certifier = Utils.toHex(certifierBytes)
+          // Serialize the result
+          const resultWriter = new Utils.Writer();
 
-            // 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 prover
+          resultWriter.write(Utils.toArray(revealResult.prover, "hex"));
 
-              const fieldValueLength = paramsReader.readVarIntNum()
-              const fieldValueBytes = paramsReader.read(fieldValueLength)
-              const fieldValue = Utils.toUTF8(fieldValueBytes)
+          // Write verifier
+          resultWriter.write(Utils.toArray(revealResult.verifier, "hex"));
 
-              args.fields[fieldName] = fieldValue
-            }
+          // Write counterparty
+          resultWriter.write(Utils.toArray(revealResult.counterparty, "hex"));
 
-            // Read privileged parameters
-            const privilegedFlag = paramsReader.readInt8()
-            if (privilegedFlag === -1) {
-              args.privileged = undefined
-            } else {
-              args.privileged = privilegedFlag === 1
-            }
+          // Write securityLevel
+          resultWriter.writeUInt8(revealResult.protocolID[0]);
 
-            const privilegedReasonLength = paramsReader.readInt8()
-            if (privilegedReasonLength === -1) {
-              args.privilegedReason = undefined
-            } else {
-              const privilegedReasonBytes = paramsReader.read(privilegedReasonLength)
-              args.privilegedReason = Utils.toUTF8(privilegedReasonBytes)
-            }
+          // Write protocol string
+          const protocolBytesOut = Utils.toArray(
+            revealResult.protocolID[1],
+            "utf8"
+          );
+          resultWriter.writeVarIntNum(protocolBytesOut.length);
+          resultWriter.write(protocolBytesOut);
 
-            // Read acquisitionProtocol
-            const acquisitionProtocolFlag = paramsReader.readUInt8()
-            args.acquisitionProtocol = acquisitionProtocolFlag === 1 ? 'direct' : 'issuance'
+          // Write keyID
+          const keyIDBytesOut = Utils.toArray(revealResult.keyID, "utf8");
+          resultWriter.writeVarIntNum(keyIDBytesOut.length);
+          resultWriter.write(keyIDBytesOut);
 
-            if (args.acquisitionProtocol === 'direct') {
-              // args.serialNumber
-              const serialNumberBytes = paramsReader.read(32)
-              args.serialNumber = Utils.toBase64(serialNumberBytes)
+          // Write encryptedLinkage
+          resultWriter.writeVarIntNum(revealResult.encryptedLinkage.length);
+          resultWriter.write(revealResult.encryptedLinkage);
 
-              // args.revocationOutpoint
-              args.revocationOutpoint = this.decodeOutpoint(paramsReader)
+          // Write encryptedLinkageProof
+          resultWriter.writeVarIntNum(
+            revealResult.encryptedLinkageProof.length
+          );
+          resultWriter.write(revealResult.encryptedLinkageProof);
 
-              // args.signature
-              const signatureLength = paramsReader.readVarIntNum()
-              const signatureBytes = paramsReader.read(signatureLength)
-              args.signature = Utils.toHex(signatureBytes)
+          // Write proofType
+          resultWriter.writeUInt8(revealResult.proofType);
 
-              // 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)
-              }
+          // Return success code and result
+          const responseWriter = new Utils.Writer();
+          responseWriter.writeUInt8(0); // errorByte = 0
+          responseWriter.write(resultWriter.toArray());
+          return responseWriter.toArray();
+        }
+
+        case "acquireCertificate": {
+          const args: any = {};
+
+          // Read args.type
+          const typeBytes = paramsReader.read(32);
+          args.type = Utils.toBase64(typeBytes);
+
+          // args.certifier
+          const certifierBytes = paramsReader.read(33);
+          args.certifier = Utils.toHex(certifierBytes);
+
+          // 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);
+
+            const fieldValueLength = paramsReader.readVarIntNum();
+            const fieldValueBytes = paramsReader.read(fieldValueLength);
+            const fieldValue = Utils.toUTF8(fieldValueBytes);
+
+            args.fields[fieldName] = fieldValue;
+          }
 
-              // 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)
+          // Read privileged parameters
+          const privilegedFlag = paramsReader.readInt8();
+          if (privilegedFlag === -1) {
+            args.privileged = undefined;
+          } else {
+            args.privileged = privilegedFlag === 1;
+          }
 
-                const fieldValueLength = paramsReader.readVarIntNum()
-                const fieldValueBytes = paramsReader.read(fieldValueLength)
-                const fieldValue = Utils.toBase64(fieldValueBytes)
+          const privilegedReasonLength = paramsReader.readInt8();
+          if (privilegedReasonLength === -1) {
+            args.privilegedReason = undefined;
+          } else {
+            const privilegedReasonBytes = paramsReader.read(
+              privilegedReasonLength
+            );
+            args.privilegedReason = Utils.toUTF8(privilegedReasonBytes);
+          }
 
-                args.keyringForSubject[fieldKey] = fieldValue
-              }
-            } else {
-              // args.certifierUrl
-              const certifierUrlLength = paramsReader.readVarIntNum()
-              const certifierUrlBytes = paramsReader.read(certifierUrlLength)
-              args.certifierUrl = Utils.toUTF8(certifierUrlBytes)
-            }
+          // Read acquisitionProtocol
+          const acquisitionProtocolFlag = paramsReader.readUInt8();
+          args.acquisitionProtocol =
+            acquisitionProtocolFlag === 1 ? "direct" : "issuance";
 
-            // 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 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))
-            }
+          if (args.acquisitionProtocol === "direct") {
+            // args.serialNumber
+            const serialNumberBytes = paramsReader.read(32);
+            args.serialNumber = Utils.toBase64(serialNumberBytes);
 
-            // 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))
-            }
+            // args.revocationOutpoint
+            args.revocationOutpoint = this.decodeOutpoint(paramsReader);
 
-            // Read limit and offset
-            const limit = paramsReader.readVarIntNum()
-            if (limit >= 0) {
-              args.limit = limit
-            } else {
-              args.limit = undefined
-            }
+            // args.signature
+            const signatureLength = paramsReader.readVarIntNum();
+            const signatureBytes = paramsReader.read(signatureLength);
+            args.signature = Utils.toHex(signatureBytes);
 
-            const offset = paramsReader.readVarIntNum()
-            if (offset >= 0) {
-              args.offset = offset
+            // args.keyringRevealer
+            const keyringRevealerIdentifier = paramsReader.readUInt8();
+            if (keyringRevealerIdentifier === 11) {
+              args.keyringRevealer = "certifier";
             } else {
-              args.offset = undefined
+              const keyringRevealerBytes = [keyringRevealerIdentifier].concat(
+                paramsReader.read(32)
+              );
+              args.keyringRevealer = Utils.toHex(keyringRevealerBytes);
             }
 
-            // Read privileged parameters
-            const privilegedFlag = paramsReader.readInt8()
-            if (privilegedFlag === -1) {
-              args.privileged = undefined
-            } else {
-              args.privileged = privilegedFlag === 1
-            }
+            // 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);
 
-            const privilegedReasonLength = paramsReader.readInt8()
-            if (privilegedReasonLength === -1) {
-              args.privilegedReason = undefined
-            } else {
-              const privilegedReasonBytes = paramsReader.read(privilegedReasonLength)
-              args.privilegedReason = Utils.toUTF8(privilegedReasonBytes)
-            }
+              const fieldValueLength = paramsReader.readVarIntNum();
+              const fieldValueBytes = paramsReader.read(fieldValueLength);
+              const fieldValue = Utils.toBase64(fieldValueBytes);
 
-            // 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()
-
-              // Write certificate binary length and data
-              resultWriter.writeVarIntNum(certBin.length)
-              resultWriter.write(certBin)
+              args.keyringForSubject[fieldKey] = fieldValue;
             }
+          } else {
+            // args.certifierUrl
+            const certifierUrlLength = paramsReader.readVarIntNum();
+            const certifierUrlBytes = paramsReader.read(certifierUrlLength);
+            args.certifierUrl = Utils.toUTF8(certifierUrlBytes);
+          }
 
-            // Return the response
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            responseWriter.write(resultWriter.toArray())
-            return responseWriter.toArray()
+          // 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 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));
           }
 
-        case 'proveCertificate':
-          {
-            const args: any = {}
+          // 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));
+          }
 
-            // Read certificate
-            const cert: 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)
-            cert.type = Utils.toBase64(typeBytes)
+          const offset = paramsReader.readVarIntNum();
+          if (offset >= 0) {
+            args.offset = offset;
+          } else {
+            args.offset = undefined;
+          }
 
-            // Read subject
-            const subjectBytes = paramsReader.read(33)
-            cert.subject = Utils.toHex(subjectBytes)
+          // Read privileged parameters
+          const privilegedFlag = paramsReader.readInt8();
+          if (privilegedFlag === -1) {
+            args.privileged = undefined;
+          } else {
+            args.privileged = privilegedFlag === 1;
+          }
 
-            // Read serialNumber
-            const serialNumberBytes = paramsReader.read(32)
-            cert.serialNumber = Utils.toBase64(serialNumberBytes)
+          const privilegedReasonLength = paramsReader.readInt8();
+          if (privilegedReasonLength === -1) {
+            args.privilegedReason = undefined;
+          } else {
+            const privilegedReasonBytes = paramsReader.read(
+              privilegedReasonLength
+            );
+            args.privilegedReason = Utils.toUTF8(privilegedReasonBytes);
+          }
 
-            // Read certifier
-            const certifierBytes = paramsReader.read(33)
-            cert.certifier = Utils.toHex(certifierBytes)
+          // Call the method
+          const listResult = await this.wallet.listCertificates(
+            args,
+            originator
+          );
 
-            // Read revocationOutpoint
-            cert.revocationOutpoint = this.decodeOutpoint(paramsReader)
+          // 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();
+
+            // Write certificate binary length and data
+            resultWriter.writeVarIntNum(certBin.length);
+            resultWriter.write(certBin);
+          }
 
-            // Read signature
-            const signatureLength = paramsReader.readVarIntNum()
-            const signatureBytes = paramsReader.read(signatureLength)
-            cert.signature = Utils.toHex(signatureBytes)
+          // Return the response
+          const responseWriter = new Utils.Writer();
+          responseWriter.writeUInt8(0); // errorByte = 0
+          responseWriter.write(resultWriter.toArray());
+          return responseWriter.toArray();
+        }
 
-            // 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)
+        case "proveCertificate": {
+          const args: any = {};
 
-              const fieldValueLength = paramsReader.readVarIntNum()
-              const fieldValueBytes = paramsReader.read(fieldValueLength)
-              const fieldValue = Utils.toUTF8(fieldValueBytes)
+          // Read certificate
+          const cert: any = {};
 
-              cert.fields[fieldName] = fieldValue
-            }
+          // Read type
+          const typeBytes = paramsReader.read(32);
+          cert.type = Utils.toBase64(typeBytes);
 
-            args.certificate = cert
+          // Read subject
+          const subjectBytes = paramsReader.read(33);
+          cert.subject = Utils.toHex(subjectBytes);
 
-            // 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);
+          cert.serialNumber = Utils.toBase64(serialNumberBytes);
 
-            // Read verifier
-            const verifierBytes = paramsReader.read(33)
-            args.verifier = Utils.toHex(verifierBytes)
+          // 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
-            }
+          // Read revocationOutpoint
+          cert.revocationOutpoint = this.decodeOutpoint(paramsReader);
 
-            const privilegedReasonLength = paramsReader.readInt8()
-            if (privilegedReasonLength === -1) {
-              args.privilegedReason = undefined
-            } else {
-              const privilegedReasonBytes = paramsReader.read(privilegedReasonLength)
-              args.privilegedReason = Utils.toUTF8(privilegedReasonBytes)
-            }
+          // Read signature
+          const signatureLength = paramsReader.readVarIntNum();
+          const signatureBytes = paramsReader.read(signatureLength);
+          cert.signature = Utils.toHex(signatureBytes);
 
-            // Call the method
-            const proveResult = await this.wallet.proveCertificate(args, originator)
+          // 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);
 
-            // Serialize keyringForVerifier
-            const resultWriter = new Utils.Writer()
+            const fieldValueLength = paramsReader.readVarIntNum();
+            const fieldValueBytes = paramsReader.read(fieldValueLength);
+            const fieldValue = Utils.toUTF8(fieldValueBytes);
 
-            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)
+            cert.fields[fieldName] = fieldValue;
+          }
 
-              const fieldValueBytes = Utils.toArray(fieldValue, 'base64')
-              resultWriter.writeVarIntNum(fieldValueBytes.length)
-              resultWriter.write(fieldValueBytes)
-            }
+          args.certificate = cert;
 
-            // Return the response
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            responseWriter.write(resultWriter.toArray())
-            return responseWriter.toArray()
+          // 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);
           }
 
-        case 'relinquishCertificate':
-          {
-            const args: any = {}
+          // Read verifier
+          const verifierBytes = paramsReader.read(33);
+          args.verifier = Utils.toHex(verifierBytes);
 
-            // Read type
-            const typeBytes = paramsReader.read(32)
-            args.type = Utils.toBase64(typeBytes)
+          // Read privileged parameters
+          const privilegedFlag = paramsReader.readInt8();
+          if (privilegedFlag === -1) {
+            args.privileged = undefined;
+          } else {
+            args.privileged = privilegedFlag === 1;
+          }
 
-            // Read serialNumber
-            const serialNumberBytes = paramsReader.read(32)
-            args.serialNumber = Utils.toBase64(serialNumberBytes)
+          const privilegedReasonLength = paramsReader.readInt8();
+          if (privilegedReasonLength === -1) {
+            args.privilegedReason = undefined;
+          } else {
+            const privilegedReasonBytes = paramsReader.read(
+              privilegedReasonLength
+            );
+            args.privilegedReason = Utils.toUTF8(privilegedReasonBytes);
+          }
 
-            // Read certifier
-            const certifierBytes = paramsReader.read(33)
-            args.certifier = Utils.toHex(certifierBytes)
+          // Call the method
+          const proveResult = await this.wallet.proveCertificate(
+            args,
+            originator
+          );
+
+          // Serialize keyringForVerifier
+          const resultWriter = new Utils.Writer();
+
+          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);
+
+            const fieldValueBytes = Utils.toArray(fieldValue, "base64");
+            resultWriter.writeVarIntNum(fieldValueBytes.length);
+            resultWriter.write(fieldValueBytes);
+          }
 
-            // Call the method
-            await this.wallet.relinquishCertificate(args, originator)
+          // Return the response
+          const responseWriter = new Utils.Writer();
+          responseWriter.writeUInt8(0); // errorByte = 0
+          responseWriter.write(resultWriter.toArray());
+          return responseWriter.toArray();
+        }
 
-            // Return success code
-            const responseWriter = new Utils.Writer()
-            responseWriter.writeUInt8(0) // errorByte = 0
-            return responseWriter.toArray()
-          }
+        case "relinquishCertificate": {
+          const args: any = {};
 
-        case 'discoverByIdentityKey':
-          {
-            const args: any = {}
+          // Read type
+          const typeBytes = paramsReader.read(32);
+          args.type = Utils.toBase64(typeBytes);
 
-            // Read identityKey
-            const identityKeyBytes = paramsReader.read(33)
-            args.identityKey = Utils.toHex(identityKeyBytes)
+          // Read 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
-            }
+          // Read certifier
+          const certifierBytes = paramsReader.read(33);
+          args.certifier = Utils.toHex(certifierBytes);
 
-            const offset = paramsReader.readVarIntNum()
-            if (offset >= 0) {
-              args.offset = offset
-            } else {
-              args.offset = undefined
-            }
+          // Call the method
+          await this.wallet.relinquishCertificate(args, originator);
 
-            // Deserialize seekPermission
-            const seekPermission = paramsReader.readInt8()
-            if (seekPermission >= 0) {
-              args.seekPermission = seekPermission === 1
-            } else {
-              args.seekPermission = undefined
-            }
+          // Return success code
+          const responseWriter = new Utils.Writer();
+          responseWriter.writeUInt8(0); // errorByte = 0
+          return responseWriter.toArray();
+        }
 
-            // Call the method
-            const discoverResult = await this.wallet.discoverByIdentityKey(args, originator)
+        case "discoverByIdentityKey": {
+          const args: any = {};
 
-            // Serialize the result
-            const result = this.serializeDiscoveryResult(discoverResult)
+          // 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);
+
+          // Return the response
+          const responseWriter = new Utils.Writer();
+          responseWriter.writeUInt8(0); // errorByte = 0
+          responseWriter.write(result);
+          return responseWriter.toArray();
+        }
+
+        case "discoverByAttributes": {
+          const args: any = {};
+
+          // 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);
+
+            args.attributes[fieldKey] = fieldValue;
+          }
 
-            // Read limit and offset
-            const limit = paramsReader.readVarIntNum()
-            if (limit >= 0) {
-              args.limit = limit
-            } else {
-              args.limit = undefined
-            }
+          // Read limit and offset
+          const limit = paramsReader.readVarIntNum();
+          if (limit >= 0) {
+            args.limit = limit;
+          } else {
+            args.limit = undefined;
+          }
 
-            const offset = paramsReader.readVarIntNum()
-            if (offset >= 0) {
-              args.offset = offset
-            } else {
-              args.offset = undefined
-            }
+          const offset = paramsReader.readVarIntNum();
+          if (offset >= 0) {
+            args.offset = offset;
+          } else {
+            args.offset = undefined;
+          }
 
-            // Deserialize seekPermission
-            const seekPermission = paramsReader.readInt8()
-            if (seekPermission >= 0) {
-              args.seekPermission = seekPermission === 1
-            } else {
-              args.seekPermission = undefined
-            }
+          // 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)
+          // Call the method
+          const discoverResult = await this.wallet.discoverByAttributes(
+            args,
+            originator
+          );
 
-            // Serialize the result
-            const result = this.serializeDiscoveryResult(discoverResult)
+          // 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()
-          }
+          // 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`)
+          throw new Error(`Method ${callName} not implemented`);
       }
     } catch (err) {
-      const responseWriter = new Utils.Writer()
-      responseWriter.writeUInt8((err).code || 1) // errorCode = 1 (generic error)
+      const responseWriter = new Utils.Writer();
+      responseWriter.writeUInt8(err.code || 1); // errorCode = 1 (generic error)
 
       // Serialize the error message
-      const errorMessage = err.message || 'Unknown error'
-      const errorMessageBytes = Utils.toArray(errorMessage, 'utf8')
-      responseWriter.writeVarIntNum(errorMessageBytes.length)
-      responseWriter.write(errorMessageBytes)
+      const errorMessage = 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 stackTraceBytes = Utils.toArray(stackTrace, 'utf8')
-      responseWriter.writeVarIntNum(stackTraceBytes.length)
-      responseWriter.write(stackTraceBytes)
+      const stackTrace = err.stack || "";
+      const stackTraceBytes = Utils.toArray(stackTrace, "utf8");
+      responseWriter.writeVarIntNum(stackTraceBytes.length);
+      responseWriter.write(stackTraceBytes);
 
-      return responseWriter.toArray()
+      return responseWriter.toArray();
     }
   }
 
   private decodeProtocolID(reader: Utils.Reader): [SecurityLevel, string] {
-    const securityLevel = reader.readUInt8() as SecurityLevel
-    const protocolLength = reader.readVarIntNum()
-    const protocolBytes = reader.read(protocolLength)
-    const protocolString = Utils.toUTF8(protocolBytes)
-    return [securityLevel, protocolString]
+    const securityLevel = reader.readUInt8() as SecurityLevel;
+    const protocolLength = reader.readVarIntNum();
+    const protocolBytes = reader.read(protocolLength);
+    const protocolString = Utils.toUTF8(protocolBytes);
+    return [securityLevel, protocolString];
   }
 
   private decodeString(reader: Utils.Reader): string {
-    const length = reader.readVarIntNum()
-    const bytes = reader.read(length)
-    return Utils.toUTF8(bytes)
+    const length = reader.readVarIntNum();
+    const bytes = reader.read(length);
+    return Utils.toUTF8(bytes);
   }
 
-  private decodeCounterparty(reader: Utils.Reader): string | 'self' | 'anyone' | undefined {
-    const counterpartyFlag = reader.readUInt8()
+  private decodeCounterparty(
+    reader: Utils.Reader
+  ): string | "self" | "anyone" | undefined {
+    const counterpartyFlag = reader.readUInt8();
     if (counterpartyFlag === 11) {
-      return 'self'
+      return "self";
     } else if (counterpartyFlag === 12) {
-      return 'anyone'
+      return "anyone";
     } else if (counterpartyFlag === 0) {
-      return undefined
+      return undefined;
     } else {
-      const counterpartyRemainingBytes = reader.read(32)
-      return Utils.toHex([counterpartyFlag, ...counterpartyRemainingBytes])
+      const counterpartyRemainingBytes = reader.read(32);
+      return Utils.toHex([counterpartyFlag, ...counterpartyRemainingBytes]);
     }
   }
 
   private serializeDiscoveryResult(discoverResult: any): number[] {
-    const resultWriter = new Utils.Writer()
+    const resultWriter = new Utils.Writer();
 
     // totalCertificates
-    resultWriter.writeVarIntNum(discoverResult.totalCertificates)
+    resultWriter.writeVarIntNum(discoverResult.totalCertificates);
 
     // certificates
     for (const cert of discoverResult.certificates) {
@@ -1960,88 +2093,91 @@ export default class WalletWireProcessor implements WalletWire {
         cert.revocationOutpoint,
         cert.fields,
         cert.signaturre
-      )
-      const certBin = certificate.toBinary()
+      );
+      const certBin = certificate.toBinary();
 
       // Write certificate binary length and data
-      resultWriter.writeVarIntNum(certBin.length)
-      resultWriter.write(certBin)
+      resultWriter.writeVarIntNum(certBin.length);
+      resultWriter.write(certBin);
 
       // Serialize certifierInfo
-      const nameBytes = Utils.toArray(cert.certifierInfo.name, 'utf8')
-      resultWriter.writeVarIntNum(nameBytes.length)
-      resultWriter.write(nameBytes)
+      const nameBytes = Utils.toArray(cert.certifierInfo.name, "utf8");
+      resultWriter.writeVarIntNum(nameBytes.length);
+      resultWriter.write(nameBytes);
 
-      const iconUrlBytes = Utils.toArray(cert.certifierInfo.iconUrl, 'utf8')
-      resultWriter.writeVarIntNum(iconUrlBytes.length)
-      resultWriter.write(iconUrlBytes)
+      const iconUrlBytes = Utils.toArray(cert.certifierInfo.iconUrl, "utf8");
+      resultWriter.writeVarIntNum(iconUrlBytes.length);
+      resultWriter.write(iconUrlBytes);
 
-      const descriptionBytes = Utils.toArray(cert.certifierInfo.description, 'utf8')
-      resultWriter.writeVarIntNum(descriptionBytes.length)
-      resultWriter.write(descriptionBytes)
+      const descriptionBytes = Utils.toArray(
+        cert.certifierInfo.description,
+        "utf8"
+      );
+      resultWriter.writeVarIntNum(descriptionBytes.length);
+      resultWriter.write(descriptionBytes);
 
-      resultWriter.writeUInt8(cert.certifierInfo.trust)
+      resultWriter.writeUInt8(cert.certifierInfo.trust);
 
       // Serialize publiclyRevealedKeyring
-      const publicKeyringEntries = Object.entries(cert.publiclyRevealedKeyring)
-      resultWriter.writeVarIntNum(publicKeyringEntries.length)
+      const publicKeyringEntries = Object.entries(cert.publiclyRevealedKeyring);
+      resultWriter.writeVarIntNum(publicKeyringEntries.length);
       for (const [fieldName, fieldValue] of publicKeyringEntries) {
-        const fieldNameBytes = Utils.toArray(fieldName, 'utf8')
-        resultWriter.writeVarIntNum(fieldNameBytes.length)
-        resultWriter.write(fieldNameBytes)
+        const fieldNameBytes = Utils.toArray(fieldName, "utf8");
+        resultWriter.writeVarIntNum(fieldNameBytes.length);
+        resultWriter.write(fieldNameBytes);
 
-        const fieldValueBytes = Utils.toArray(fieldValue, 'base64')
-        resultWriter.writeVarIntNum(fieldValueBytes.length)
-        resultWriter.write(fieldValueBytes)
+        const fieldValueBytes = Utils.toArray(fieldValue, "base64");
+        resultWriter.writeVarIntNum(fieldValueBytes.length);
+        resultWriter.write(fieldValueBytes);
       }
 
       // Serialize decryptedFields
-      const decryptedFieldEntries = Object.entries(cert.decryptedFields)
-      resultWriter.writeVarIntNum(decryptedFieldEntries.length)
+      const decryptedFieldEntries = Object.entries(cert.decryptedFields);
+      resultWriter.writeVarIntNum(decryptedFieldEntries.length);
       for (const [fieldName, fieldValue] of decryptedFieldEntries) {
-        const fieldNameBytes = Utils.toArray(fieldName, 'utf8')
-        resultWriter.writeVarIntNum(fieldNameBytes.length)
-        resultWriter.write(fieldNameBytes)
+        const fieldNameBytes = Utils.toArray(fieldName, "utf8");
+        resultWriter.writeVarIntNum(fieldNameBytes.length);
+        resultWriter.write(fieldNameBytes);
 
-        const fieldValueBytes = Utils.toArray(fieldValue, 'utf8')
-        resultWriter.writeVarIntNum(fieldValueBytes.length)
-        resultWriter.write(fieldValueBytes)
+        const fieldValueBytes = Utils.toArray(fieldValue, "utf8");
+        resultWriter.writeVarIntNum(fieldValueBytes.length);
+        resultWriter.write(fieldValueBytes);
       }
     }
 
-    return resultWriter.toArray()
+    return resultWriter.toArray();
   }
 
   private decodeKeyRelatedParams(paramsReader: Utils.Reader): any {
-    const args: any = {}
+    const args: any = {};
 
     // Read protocolID
-    args.protocolID = this.decodeProtocolID(paramsReader)
+    args.protocolID = this.decodeProtocolID(paramsReader);
 
     // Read keyID
-    const keyIDLength = paramsReader.readVarIntNum()
-    const keyIDBytes = paramsReader.read(keyIDLength)
-    args.keyID = Utils.toUTF8(keyIDBytes)
+    const keyIDLength = paramsReader.readVarIntNum();
+    const keyIDBytes = paramsReader.read(keyIDLength);
+    args.keyID = Utils.toUTF8(keyIDBytes);
 
     // Read counterparty
-    args.counterparty = this.decodeCounterparty(paramsReader)
+    args.counterparty = this.decodeCounterparty(paramsReader);
 
     // Read privileged parameters
-    const privilegedFlag = paramsReader.readInt8()
+    const privilegedFlag = paramsReader.readInt8();
     if (privilegedFlag === -1) {
-      args.privileged = undefined
+      args.privileged = undefined;
     } else {
-      args.privileged = privilegedFlag === 1
+      args.privileged = privilegedFlag === 1;
     }
 
-    const privilegedReasonLength = paramsReader.readInt8()
+    const privilegedReasonLength = paramsReader.readInt8();
     if (privilegedReasonLength === -1) {
-      args.privilegedReason = undefined
+      args.privilegedReason = undefined;
     } else {
-      const privilegedReasonBytes = paramsReader.read(privilegedReasonLength)
-      args.privilegedReason = Utils.toUTF8(privilegedReasonBytes)
+      const privilegedReasonBytes = paramsReader.read(privilegedReasonLength);
+      args.privilegedReason = Utils.toUTF8(privilegedReasonBytes);
     }
 
-    return args
+    return args;
   }
 }