@bsv/sdk 1.3.13 → 1.3.14

package/src/wallet/substrates/WalletWireProcessor.ts

@@ -1,1685 +1,1684 @@
-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";
+import { WalletInterface, SecurityLevel } from '../Wallet.interfaces.js'
+import WalletWire from './WalletWire.js'
+import { Utils } from '../../primitives/index.js'
+import calls from './WalletWireCalls.js'
+import Certificate from '../../auth/certificates/Certificate.js'
 
 /**
  * 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
-      if (!callName) {
+      const callName = calls[callCode] // calls is enum
+      if (callName === undefined || 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);
+                )
+                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 inputDescriptionLength = paramsReader.readVarIntNum()
               const inputDescriptionBytes = paramsReader.read(
                 inputDescriptionLength
-              );
-              input.inputDescription = Utils.toUTF8(inputDescriptionBytes);
+              )
+              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 outputDescriptionLength = paramsReader.readVarIntNum()
               const outputDescriptionBytes = paramsReader.read(
                 outputDescriptionLength
-              );
-              output.outputDescription = Utils.toUTF8(outputDescriptionBytes);
+              )
+              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
-                );
+                )
               } 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;
+                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
-          );
+          )
 
           // 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"));
+          if (createActionResult.txid != null && createActionResult.txid !== '') {
+            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);
+          if (createActionResult.tx != null) {
+            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);
+          if (createActionResult.noSendChange != null) {
+            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) {
+          if (createActionResult.sendWithResults != null) {
             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);
+          if (createActionResult.signableTransaction != null) {
+            resultWriter.writeInt8(1)
             resultWriter.writeVarIntNum(
               createActionResult.signableTransaction.tx.length
-            );
-            resultWriter.write(createActionResult.signableTransaction.tx);
+            )
+            resultWriter.write(createActionResult.signableTransaction.tx)
             const referenceBytes = Utils.toArray(
               createActionResult.signableTransaction.reference,
-              "base64"
-            );
-            resultWriter.writeVarIntNum(referenceBytes.length);
-            resultWriter.write(referenceBytes);
+              '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 = {};
+          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 = {};
+          const spendCount = paramsReader.readVarIntNum()
+          args.spends = {}
           for (let i = 0; i < spendCount; i++) {
-            const inputIndex = paramsReader.readVarIntNum();
-            const spend: any = {};
+            const inputIndex = paramsReader.readVarIntNum()
+            const spend: any = {}
 
             // unlockingScript
-            const unlockingScriptLength = paramsReader.readVarIntNum();
+            const unlockingScriptLength = paramsReader.readVarIntNum()
             const unlockingScriptBytes = paramsReader.read(
               unlockingScriptLength
-            );
-            spend.unlockingScript = Utils.toHex(unlockingScriptBytes);
+            )
+            spend.unlockingScript = Utils.toHex(unlockingScriptBytes)
 
             // sequenceNumber
-            const sequenceNumber = paramsReader.readVarIntNum();
+            const sequenceNumber = paramsReader.readVarIntNum()
             if (sequenceNumber >= 0) {
-              spend.sequenceNumber = sequenceNumber;
+              spend.sequenceNumber = sequenceNumber
             } else {
-              spend.sequenceNumber = undefined;
+              spend.sequenceNumber = undefined
             }
 
-            args.spends[inputIndex] = spend;
+            args.spends[inputIndex] = spend
           }
 
           // Deserialize reference
-          const referenceLength = paramsReader.readVarIntNum();
-          const referenceBytes = paramsReader.read(referenceLength);
-          args.reference = Utils.toBase64(referenceBytes);
+          const referenceLength = paramsReader.readVarIntNum()
+          const referenceBytes = paramsReader.read(referenceLength)
+          args.reference = Utils.toBase64(referenceBytes)
 
           // Deserialize options
-          const optionsPresent = paramsReader.readInt8();
+          const optionsPresent = paramsReader.readInt8()
           if (optionsPresent === 1) {
-            args.options = {};
+            args.options = {}
 
             // 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;
+                acceptDelayedBroadcastFlag === 1
             }
 
             // 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
             }
 
             // 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
             }
           } else {
-            args.options = undefined;
+            args.options = undefined
           }
 
           // Call the method
           const signActionResult = await this.wallet.signAction(
             args,
             originator
-          );
+          )
 
           // Serialize the result
-          const resultWriter = new Utils.Writer();
+          const resultWriter = new Utils.Writer()
 
           // txid
-          if (signActionResult.txid) {
-            resultWriter.writeInt8(1);
-            resultWriter.write(Utils.toArray(signActionResult.txid, "hex"));
+          if (signActionResult.txid != null && signActionResult.txid !== '') {
+            resultWriter.writeInt8(1)
+            resultWriter.write(Utils.toArray(signActionResult.txid, 'hex'))
           } else {
-            resultWriter.writeInt8(0);
+            resultWriter.writeInt8(0)
           }
 
           // tx
-          if (signActionResult.tx) {
-            resultWriter.writeInt8(1);
-            resultWriter.writeVarIntNum(signActionResult.tx.length);
-            resultWriter.write(signActionResult.tx);
+          if (signActionResult.tx != null) {
+            resultWriter.writeInt8(1)
+            resultWriter.writeVarIntNum(signActionResult.tx.length)
+            resultWriter.write(signActionResult.tx)
           } else {
-            resultWriter.writeInt8(0);
+            resultWriter.writeInt8(0)
           }
 
           // sendWithResults
-          if (signActionResult.sendWithResults) {
+          if (signActionResult.sendWithResults != null) {
             resultWriter.writeVarIntNum(
               signActionResult.sendWithResults.length
-            );
+            )
             for (const result of signActionResult.sendWithResults) {
-              resultWriter.write(Utils.toArray(result.txid, "hex"));
-              let statusCode;
-              if (result.status === "unproven") statusCode = 1;
-              else if (result.status === "sending") statusCode = 2;
-              else if (result.status === "failed") statusCode = 3;
-              resultWriter.writeInt8(statusCode);
+              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)
           }
 
           // Return success code and result
-          const responseWriter = new Utils.Writer();
-          responseWriter.writeUInt8(0); // errorByte = 0
-          responseWriter.write(resultWriter.toArray());
-          return responseWriter.toArray();
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.write(resultWriter.toArray())
+          return responseWriter.toArray()
         }
-        case "abortAction": {
+        case 'abortAction': {
           // Deserialize reference
-          const referenceBytes = paramsReader.read();
-          const reference = Utils.toBase64(referenceBytes);
+          const referenceBytes = paramsReader.read()
+          const reference = Utils.toBase64(referenceBytes)
 
           // Call the method
-          await this.wallet.abortAction({ reference }, originator);
+          await this.wallet.abortAction({ reference }, originator)
 
           // Return success code and result
-          const responseWriter = new Utils.Writer();
-          responseWriter.writeUInt8(0); // errorByte = 0
-          return responseWriter.toArray();
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          return responseWriter.toArray()
         }
-        case "listActions": {
-          const args: any = {};
+        case 'listActions': {
+          const args: any = {}
 
           // Deserialize labels
-          const labelsLength = paramsReader.readVarIntNum();
-          args.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));
+            const labelLength = paramsReader.readVarIntNum()
+            const labelBytes = paramsReader.read(labelLength)
+            args.labels.push(Utils.toUTF8(labelBytes))
           }
 
           // Deserialize labelQueryMode
-          const labelQueryModeFlag = paramsReader.readInt8();
+          const labelQueryModeFlag = paramsReader.readInt8()
           if (labelQueryModeFlag === -1) {
-            args.labelQueryMode = undefined;
+            args.labelQueryMode = undefined
           } else if (labelQueryModeFlag === 1) {
-            args.labelQueryMode = "any";
+            args.labelQueryMode = 'any'
           } else if (labelQueryModeFlag === 2) {
-            args.labelQueryMode = "all";
+            args.labelQueryMode = 'all'
           }
 
           // Deserialize include options
           const includeOptionsNames = [
-            "includeLabels",
-            "includeInputs",
-            "includeInputSourceLockingScripts",
-            "includeInputUnlockingScripts",
-            "includeOutputs",
-            "includeOutputLockingScripts",
-          ];
+            'includeLabels',
+            'includeInputs',
+            'includeInputSourceLockingScripts',
+            'includeInputUnlockingScripts',
+            'includeOutputs',
+            'includeOutputLockingScripts'
+          ]
           for (const optionName of includeOptionsNames) {
-            const optionFlag = paramsReader.readInt8();
+            const optionFlag = paramsReader.readInt8()
             if (optionFlag === -1) {
-              args[optionName] = undefined;
+              args[optionName] = undefined
             } else {
-              args[optionName] = optionFlag === 1;
+              args[optionName] = optionFlag === 1
             }
           }
 
           // Deserialize limit
-          const limit = paramsReader.readVarIntNum();
+          const limit = paramsReader.readVarIntNum()
           if (limit >= 0) {
-            args.limit = limit;
+            args.limit = limit
           } else {
-            args.limit = undefined;
+            args.limit = undefined
           }
 
           // Deserialize offset
-          const offset = paramsReader.readVarIntNum();
+          const offset = paramsReader.readVarIntNum()
           if (offset >= 0) {
-            args.offset = offset;
+            args.offset = offset
           } else {
-            args.offset = undefined;
+            args.offset = undefined
           }
 
           // Deserialize seekPermission
-          const seekPermission = paramsReader.readInt8();
+          const seekPermission = paramsReader.readInt8()
           if (seekPermission >= 0) {
-            args.seekPermission = seekPermission === 1;
+            args.seekPermission = seekPermission === 1
           } else {
-            args.seekPermission = undefined;
+            args.seekPermission = undefined
           }
 
           // Call the method
           const listActionsResult = await this.wallet.listActions(
             args,
             originator
-          );
+          )
 
           // Serialize the result
-          const resultWriter = new Utils.Writer();
+          const resultWriter = new Utils.Writer()
 
           // totalActions
-          resultWriter.writeVarIntNum(listActionsResult.totalActions);
+          resultWriter.writeVarIntNum(listActionsResult.totalActions)
 
           // actions
           for (const action of listActionsResult.actions) {
             // txid
-            resultWriter.write(Utils.toArray(action.txid, "hex"));
+            resultWriter.write(Utils.toArray(action.txid, 'hex'))
 
             // satoshis
-            resultWriter.writeVarIntNum(action.satoshis);
+            resultWriter.writeVarIntNum(action.satoshis)
 
             // status
-            let statusCode;
+            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;
+              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;
+                statusCode = -1
+                break
             }
-            resultWriter.writeInt8(statusCode);
+            resultWriter.writeInt8(statusCode)
 
             // isOutgoing
-            resultWriter.writeInt8(action.isOutgoing ? 1 : 0);
+            resultWriter.writeInt8(action.isOutgoing ? 1 : 0)
 
             // description
-            const descriptionBytes = Utils.toArray(action.description, "utf8");
-            resultWriter.writeVarIntNum(descriptionBytes.length);
-            resultWriter.write(descriptionBytes);
+            const descriptionBytes = Utils.toArray(action.description, 'utf8')
+            resultWriter.writeVarIntNum(descriptionBytes.length)
+            resultWriter.write(descriptionBytes)
 
             // labels
             if (action.labels !== undefined) {
-              resultWriter.writeVarIntNum(action.labels.length);
+              resultWriter.writeVarIntNum(action.labels.length)
               for (const label of action.labels) {
-                const labelBytes = Utils.toArray(label, "utf8");
-                resultWriter.writeVarIntNum(labelBytes.length);
-                resultWriter.write(labelBytes);
+                const labelBytes = Utils.toArray(label, 'utf8')
+                resultWriter.writeVarIntNum(labelBytes.length)
+                resultWriter.write(labelBytes)
               }
             } else {
-              resultWriter.writeVarIntNum(-1);
+              resultWriter.writeVarIntNum(-1)
             }
 
             // version
-            resultWriter.writeVarIntNum(action.version);
+            resultWriter.writeVarIntNum(action.version)
 
             // lockTime
-            resultWriter.writeVarIntNum(action.lockTime);
+            resultWriter.writeVarIntNum(action.lockTime)
 
             // inputs
             if (action.inputs !== undefined) {
-              resultWriter.writeVarIntNum(action.inputs.length);
+              resultWriter.writeVarIntNum(action.inputs.length)
               for (const input of action.inputs) {
                 // sourceOutpoint
-                resultWriter.write(this.encodeOutpoint(input.sourceOutpoint));
+                resultWriter.write(this.encodeOutpoint(input.sourceOutpoint))
 
                 // sourceSatoshis
-                resultWriter.writeVarIntNum(input.sourceSatoshis);
+                resultWriter.writeVarIntNum(input.sourceSatoshis)
 
                 // sourceLockingScript
                 if (input.sourceLockingScript !== undefined) {
                   const sourceLockingScriptBytes = Utils.toArray(
                     input.sourceLockingScript,
-                    "hex"
-                  );
-                  resultWriter.writeVarIntNum(sourceLockingScriptBytes.length);
-                  resultWriter.write(sourceLockingScriptBytes);
+                    'hex'
+                  )
+                  resultWriter.writeVarIntNum(sourceLockingScriptBytes.length)
+                  resultWriter.write(sourceLockingScriptBytes)
                 } else {
-                  resultWriter.writeVarIntNum(-1);
+                  resultWriter.writeVarIntNum(-1)
                 }
 
                 // unlockingScript
                 if (input.unlockingScript !== undefined) {
                   const unlockingScriptBytes = Utils.toArray(
                     input.unlockingScript,
-                    "hex"
-                  );
-                  resultWriter.writeVarIntNum(unlockingScriptBytes.length);
-                  resultWriter.write(unlockingScriptBytes);
+                    'hex'
+                  )
+                  resultWriter.writeVarIntNum(unlockingScriptBytes.length)
+                  resultWriter.write(unlockingScriptBytes)
                 } else {
-                  resultWriter.writeVarIntNum(-1);
+                  resultWriter.writeVarIntNum(-1)
                 }
 
                 // inputDescription
                 const inputDescriptionBytes = Utils.toArray(
                   input.inputDescription,
-                  "utf8"
-                );
-                resultWriter.writeVarIntNum(inputDescriptionBytes.length);
-                resultWriter.write(inputDescriptionBytes);
+                  'utf8'
+                )
+                resultWriter.writeVarIntNum(inputDescriptionBytes.length)
+                resultWriter.write(inputDescriptionBytes)
 
                 // sequenceNumber
-                resultWriter.writeVarIntNum(input.sequenceNumber);
+                resultWriter.writeVarIntNum(input.sequenceNumber)
               }
             } else {
-              resultWriter.writeVarIntNum(-1);
+              resultWriter.writeVarIntNum(-1)
             }
 
             // outputs
             if (action.outputs !== undefined) {
-              resultWriter.writeVarIntNum(action.outputs.length);
+              resultWriter.writeVarIntNum(action.outputs.length)
               for (const output of action.outputs) {
                 // outputIndex
-                resultWriter.writeVarIntNum(output.outputIndex);
+                resultWriter.writeVarIntNum(output.outputIndex)
 
                 // satoshis
-                resultWriter.writeVarIntNum(output.satoshis);
+                resultWriter.writeVarIntNum(output.satoshis)
 
                 // lockingScript
                 if (output.lockingScript !== undefined) {
                   const lockingScriptBytes = Utils.toArray(
                     output.lockingScript,
-                    "hex"
-                  );
-                  resultWriter.writeVarIntNum(lockingScriptBytes.length);
-                  resultWriter.write(lockingScriptBytes);
+                    'hex'
+                  )
+                  resultWriter.writeVarIntNum(lockingScriptBytes.length)
+                  resultWriter.write(lockingScriptBytes)
                 } else {
-                  resultWriter.writeVarIntNum(-1);
+                  resultWriter.writeVarIntNum(-1)
                 }
 
                 // spendable
-                resultWriter.writeInt8(output.spendable ? 1 : 0);
+                resultWriter.writeInt8(output.spendable ? 1 : 0)
 
                 // outputDescription
                 const outputDescriptionBytes = Utils.toArray(
                   output.outputDescription,
-                  "utf8"
-                );
-                resultWriter.writeVarIntNum(outputDescriptionBytes.length);
-                resultWriter.write(outputDescriptionBytes);
+                  '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);
+                  const basketBytes = Utils.toArray(output.basket, 'utf8')
+                  resultWriter.writeVarIntNum(basketBytes.length)
+                  resultWriter.write(basketBytes)
                 } else {
-                  resultWriter.writeVarIntNum(-1);
+                  resultWriter.writeVarIntNum(-1)
                 }
 
                 // tags
                 if (output.tags !== undefined) {
-                  resultWriter.writeVarIntNum(output.tags.length);
+                  resultWriter.writeVarIntNum(output.tags.length)
                   for (const tag of output.tags) {
-                    const tagBytes = Utils.toArray(tag, "utf8");
-                    resultWriter.writeVarIntNum(tagBytes.length);
-                    resultWriter.write(tagBytes);
+                    const tagBytes = Utils.toArray(tag, 'utf8')
+                    resultWriter.writeVarIntNum(tagBytes.length)
+                    resultWriter.write(tagBytes)
                   }
                 } else {
-                  resultWriter.writeVarIntNum(-1);
+                  resultWriter.writeVarIntNum(-1)
                 }
 
                 // customInstructions
                 if (output.customInstructions !== undefined) {
                   const customInstructionsBytes = Utils.toArray(
                     output.customInstructions,
-                    "utf8"
-                  );
-                  resultWriter.writeVarIntNum(customInstructionsBytes.length);
-                  resultWriter.write(customInstructionsBytes);
+                    'utf8'
+                  )
+                  resultWriter.writeVarIntNum(customInstructionsBytes.length)
+                  resultWriter.write(customInstructionsBytes)
                 } else {
-                  resultWriter.writeVarIntNum(-1);
+                  resultWriter.writeVarIntNum(-1)
                 }
               }
             } else {
-              resultWriter.writeVarIntNum(-1);
+              resultWriter.writeVarIntNum(-1)
             }
           }
 
-          const responseWriter = new Utils.Writer();
-          responseWriter.writeUInt8(0); // errorByte = 0
-          responseWriter.write(resultWriter.toArray());
-          return responseWriter.toArray();
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.write(resultWriter.toArray())
+          return responseWriter.toArray()
         }
-        case "internalizeAction": {
-          const args: any = {};
+        case 'internalizeAction': {
+          const args: any = {}
 
           // Read tx
-          const txLength = paramsReader.readVarIntNum();
-          args.tx = paramsReader.read(txLength);
+          const txLength = paramsReader.readVarIntNum()
+          args.tx = paramsReader.read(txLength)
 
           // Read outputs
-          const outputsLength = paramsReader.readVarIntNum();
-          args.outputs = [];
+          const outputsLength = paramsReader.readVarIntNum()
+          args.outputs = []
           for (let i = 0; i < outputsLength; i++) {
-            const output: any = {};
+            const output: any = {}
 
             // outputIndex
-            output.outputIndex = paramsReader.readVarIntNum();
+            output.outputIndex = paramsReader.readVarIntNum()
 
             // protocol
-            const protocolFlag = paramsReader.readUInt8();
+            const protocolFlag = paramsReader.readUInt8()
             if (protocolFlag === 1) {
-              output.protocol = "wallet payment";
-              output.paymentRemittance = {};
+              output.protocol = 'wallet payment'
+              output.paymentRemittance = {}
 
               // senderIdentityKey
-              const senderIdentityKeyBytes = paramsReader.read(33);
+              const senderIdentityKeyBytes = paramsReader.read(33)
               output.paymentRemittance.senderIdentityKey = Utils.toHex(
                 senderIdentityKeyBytes
-              );
+              )
 
               // derivationPrefix
-              const derivationPrefixLength = paramsReader.readVarIntNum();
+              const derivationPrefixLength = paramsReader.readVarIntNum()
               const derivationPrefixBytes = paramsReader.read(
                 derivationPrefixLength
-              );
+              )
               output.paymentRemittance.derivationPrefix = Utils.toBase64(
                 derivationPrefixBytes
-              );
+              )
 
               // derivationSuffix
-              const derivationSuffixLength = paramsReader.readVarIntNum();
+              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 = {};
+              output.protocol = 'basket insertion'
+              output.insertionRemittance = {}
 
               // basket
-              const basketLength = paramsReader.readVarIntNum();
-              const basketBytes = paramsReader.read(basketLength);
-              output.insertionRemittance.basket = Utils.toUTF8(basketBytes);
+              const basketLength = paramsReader.readVarIntNum()
+              const basketBytes = paramsReader.read(basketLength)
+              output.insertionRemittance.basket = Utils.toUTF8(basketBytes)
 
               // customInstructions
-              const customInstructionsLength = paramsReader.readVarIntNum();
+              const customInstructionsLength = paramsReader.readVarIntNum()
               if (customInstructionsLength >= 0) {
                 const customInstructionsBytes = paramsReader.read(
                   customInstructionsLength
-                );
+                )
                 output.insertionRemittance.customInstructions = Utils.toUTF8(
                   customInstructionsBytes
-                );
+                )
               }
 
               // tags
-              const tagsLength = paramsReader.readVarIntNum();
+              const tagsLength = paramsReader.readVarIntNum()
               if (tagsLength > 0) {
-                output.insertionRemittance.tags = [];
+                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));
+                  const tagLength = paramsReader.readVarIntNum()
+                  const tagBytes = paramsReader.read(tagLength)
+                  output.insertionRemittance.tags.push(Utils.toUTF8(tagBytes))
                 }
               } else {
-                output.insertionRemittance.tags = [];
+                output.insertionRemittance.tags = []
               }
             }
 
-            args.outputs.push(output);
+            args.outputs.push(output)
           }
 
-          const numberOfLabels = paramsReader.readVarIntNum();
+          const numberOfLabels = paramsReader.readVarIntNum()
           if (numberOfLabels >= 0) {
-            args.labels = [];
+            args.labels = []
             for (let i = 0; i < numberOfLabels; i++) {
-              const labelLength = paramsReader.readVarIntNum();
-              args.labels.push(Utils.toUTF8(paramsReader.read(labelLength)));
+              const labelLength = paramsReader.readVarIntNum()
+              args.labels.push(Utils.toUTF8(paramsReader.read(labelLength)))
             }
           }
 
-          const descriptionLength = paramsReader.readVarIntNum();
-          args.description = Utils.toUTF8(paramsReader.read(descriptionLength));
+          const descriptionLength = paramsReader.readVarIntNum()
+          args.description = Utils.toUTF8(paramsReader.read(descriptionLength))
 
           // Deserialize seekPermission
-          const seekPermission = paramsReader.readInt8();
+          const seekPermission = paramsReader.readInt8()
           if (seekPermission >= 0) {
-            args.seekPermission = seekPermission === 1;
+            args.seekPermission = seekPermission === 1
           } else {
-            args.seekPermission = undefined;
+            args.seekPermission = undefined
           }
 
           // Call the method
-          await this.wallet.internalizeAction(args, originator);
+          await this.wallet.internalizeAction(args, originator)
 
           // Return success code and result
-          const responseWriter = new Utils.Writer();
-          responseWriter.writeUInt8(0); // errorByte = 0
-          return responseWriter.toArray();
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          return responseWriter.toArray()
         }
 
-        case "listOutputs": {
-          const args: any = {};
+        case 'listOutputs': {
+          const args: any = {}
 
           // Deserialize basket
-          const basketLength = paramsReader.readVarIntNum();
-          const basketBytes = paramsReader.read(basketLength);
-          args.basket = Utils.toUTF8(basketBytes);
+          const basketLength = paramsReader.readVarIntNum()
+          const basketBytes = paramsReader.read(basketLength)
+          args.basket = Utils.toUTF8(basketBytes)
 
           // Deserialize tags
-          const tagsLength = paramsReader.readVarIntNum();
+          const tagsLength = paramsReader.readVarIntNum()
           if (tagsLength > 0) {
-            args.tags = [];
+            args.tags = []
             for (let i = 0; i < tagsLength; i++) {
-              const tagLength = paramsReader.readVarIntNum();
-              const tagBytes = paramsReader.read(tagLength);
-              args.tags.push(Utils.toUTF8(tagBytes));
+              const tagLength = paramsReader.readVarIntNum()
+              const tagBytes = paramsReader.read(tagLength)
+              args.tags.push(Utils.toUTF8(tagBytes))
             }
           } else {
-            args.tags = undefined;
+            args.tags = undefined
           }
 
           // Deserialize tagQueryMode
-          const tagQueryModeFlag = paramsReader.readInt8();
+          const tagQueryModeFlag = paramsReader.readInt8()
           if (tagQueryModeFlag === 1) {
-            args.tagQueryMode = "all";
+            args.tagQueryMode = 'all'
           } else if (tagQueryModeFlag === 2) {
-            args.tagQueryMode = "any";
+            args.tagQueryMode = 'any'
           } else {
-            args.tagQueryMode = undefined;
+            args.tagQueryMode = undefined
           }
 
           // Deserialize include
-          const includeFlag = paramsReader.readInt8();
+          const includeFlag = paramsReader.readInt8()
           if (includeFlag === 1) {
-            args.include = "locking scripts";
+            args.include = 'locking scripts'
           } else if (includeFlag === 2) {
-            args.include = "entire transactions";
+            args.include = 'entire transactions'
           } else {
-            args.include = undefined;
+            args.include = undefined
           }
 
           // Deserialize includeCustomInstructions
-          const includeCustomInstructionsFlag = paramsReader.readInt8();
+          const includeCustomInstructionsFlag = paramsReader.readInt8()
           if (includeCustomInstructionsFlag === -1) {
-            args.includeCustomInstructions = undefined;
+            args.includeCustomInstructions = undefined
           } else {
             args.includeCustomInstructions =
-              includeCustomInstructionsFlag === 1;
+              includeCustomInstructionsFlag === 1
           }
 
           // Deserialize includeTags
-          const includeTagsFlag = paramsReader.readInt8();
+          const includeTagsFlag = paramsReader.readInt8()
           if (includeTagsFlag === -1) {
-            args.includeTags = undefined;
+            args.includeTags = undefined
           } else {
-            args.includeTags = includeTagsFlag === 1;
+            args.includeTags = includeTagsFlag === 1
           }
 
           // Deserialize includeLabels
-          const includeLabelsFlag = paramsReader.readInt8();
+          const includeLabelsFlag = paramsReader.readInt8()
           if (includeLabelsFlag === -1) {
-            args.includeLabels = undefined;
+            args.includeLabels = undefined
           } else {
-            args.includeLabels = includeLabelsFlag === 1;
+            args.includeLabels = includeLabelsFlag === 1
           }
 
           // Deserialize limit
-          const limit = paramsReader.readVarIntNum();
+          const limit = paramsReader.readVarIntNum()
           if (limit >= 0) {
-            args.limit = limit;
+            args.limit = limit
           } else {
-            args.limit = undefined;
+            args.limit = undefined
           }
 
           // Deserialize offset
-          const offset = paramsReader.readVarIntNum();
+          const offset = paramsReader.readVarIntNum()
           if (offset >= 0) {
-            args.offset = offset;
+            args.offset = offset
           } else {
-            args.offset = undefined;
+            args.offset = undefined
           }
 
           // Deserialize seekPermission
-          const seekPermission = paramsReader.readInt8();
+          const seekPermission = paramsReader.readInt8()
           if (seekPermission >= 0) {
-            args.seekPermission = seekPermission === 1;
+            args.seekPermission = seekPermission === 1
           } else {
-            args.seekPermission = undefined;
+            args.seekPermission = undefined
           }
 
           // Call the method
           const listOutputsResult = await this.wallet.listOutputs(
             args,
             originator
-          );
+          )
 
           // Serialize the result
-          const resultWriter = new Utils.Writer();
+          const resultWriter = new Utils.Writer()
 
           // totalOutputs
-          resultWriter.writeVarIntNum(listOutputsResult.totalOutputs);
+          resultWriter.writeVarIntNum(listOutputsResult.totalOutputs)
 
           // BEEF length and BEEF or -1
-          if (listOutputsResult.BEEF) {
-            resultWriter.writeVarIntNum(listOutputsResult.BEEF.length);
-            resultWriter.write(listOutputsResult.BEEF);
+          if (listOutputsResult.BEEF != null) {
+            resultWriter.writeVarIntNum(listOutputsResult.BEEF.length)
+            resultWriter.write(listOutputsResult.BEEF)
           } else {
-            resultWriter.writeVarIntNum(-1);
+            resultWriter.writeVarIntNum(-1)
           }
 
           // outputs
           for (const output of listOutputsResult.outputs) {
             // outpoint
-            resultWriter.write(this.encodeOutpoint(output.outpoint));
+            resultWriter.write(this.encodeOutpoint(output.outpoint))
 
             // satoshis
-            resultWriter.writeVarIntNum(output.satoshis);
+            resultWriter.writeVarIntNum(output.satoshis)
 
             // lockingScript
             if (output.lockingScript !== undefined) {
               const lockingScriptBytes = Utils.toArray(
                 output.lockingScript,
-                "hex"
-              );
-              resultWriter.writeVarIntNum(lockingScriptBytes.length);
-              resultWriter.write(lockingScriptBytes);
+                'hex'
+              )
+              resultWriter.writeVarIntNum(lockingScriptBytes.length)
+              resultWriter.write(lockingScriptBytes)
             } else {
-              resultWriter.writeVarIntNum(-1);
+              resultWriter.writeVarIntNum(-1)
             }
 
             // customInstructions
             if (output.customInstructions !== undefined) {
               const customInstructionsBytes = Utils.toArray(
                 output.customInstructions,
-                "utf8"
-              );
-              resultWriter.writeVarIntNum(customInstructionsBytes.length);
-              resultWriter.write(customInstructionsBytes);
+                'utf8'
+              )
+              resultWriter.writeVarIntNum(customInstructionsBytes.length)
+              resultWriter.write(customInstructionsBytes)
             } else {
-              resultWriter.writeVarIntNum(-1);
+              resultWriter.writeVarIntNum(-1)
             }
 
             // tags
             if (output.tags !== undefined) {
-              resultWriter.writeVarIntNum(output.tags.length);
+              resultWriter.writeVarIntNum(output.tags.length)
               for (const tag of output.tags) {
-                const tagBytes = Utils.toArray(tag, "utf8");
-                resultWriter.writeVarIntNum(tagBytes.length);
-                resultWriter.write(tagBytes);
+                const tagBytes = Utils.toArray(tag, 'utf8')
+                resultWriter.writeVarIntNum(tagBytes.length)
+                resultWriter.write(tagBytes)
               }
             } else {
-              resultWriter.writeVarIntNum(-1);
+              resultWriter.writeVarIntNum(-1)
             }
 
             // labels
             if (output.labels !== undefined) {
-              resultWriter.writeVarIntNum(output.labels.length);
+              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 labelBytes = Utils.toArray(label, 'utf8')
+                resultWriter.writeVarIntNum(labelBytes.length)
+                resultWriter.write(labelBytes)
               }
             } else {
-              resultWriter.writeVarIntNum(-1);
+              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();
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.write(resultWriter.toArray())
+          return responseWriter.toArray()
         }
 
-        case "relinquishOutput": {
-          const args: any = {};
+        case 'relinquishOutput': {
+          const args: any = {}
 
           // Deserialize basket
-          const basketLength = paramsReader.readVarIntNum();
-          const basketBytes = paramsReader.read(basketLength);
-          args.basket = Utils.toUTF8(basketBytes);
+          const basketLength = paramsReader.readVarIntNum()
+          const basketBytes = paramsReader.read(basketLength)
+          args.basket = Utils.toUTF8(basketBytes)
 
           // Deserialize outpoint
-          args.output = this.decodeOutpoint(paramsReader);
+          args.output = this.decodeOutpoint(paramsReader)
 
           // Call the method
-          await this.wallet.relinquishOutput(args, originator);
+          await this.wallet.relinquishOutput(args, originator)
 
           // Return success code and result
-          const responseWriter = new Utils.Writer();
-          responseWriter.writeUInt8(0); // errorByte = 0
-          return responseWriter.toArray();
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          return responseWriter.toArray()
         }
 
-        case "getPublicKey": {
-          const args: any = {};
+        case 'getPublicKey': {
+          const args: any = {}
 
           // Deserialize identityKey flag
-          const identityKeyFlag = paramsReader.readUInt8();
-          args.identityKey = identityKeyFlag === 1;
+          const identityKeyFlag = paramsReader.readUInt8()
+          args.identityKey = identityKeyFlag === 1
 
-          if (!args.identityKey) {
+          if (args.identityKey !== true) {
             // Deserialize protocolID
-            args.protocolID = this.decodeProtocolID(paramsReader);
+            args.protocolID = this.decodeProtocolID(paramsReader)
 
             // Deserialize keyID
-            args.keyID = this.decodeString(paramsReader);
+            args.keyID = this.decodeString(paramsReader)
 
             // Deserialize counterparty
-            args.counterparty = this.decodeCounterparty(paramsReader);
+            args.counterparty = this.decodeCounterparty(paramsReader)
 
             // Deserialize privilege 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) {
               const privilegedReasonBytes = paramsReader.read(
                 privilegedReasonLength
-              );
-              args.privilegedReason = Utils.toUTF8(privilegedReasonBytes);
+              )
+              args.privilegedReason = Utils.toUTF8(privilegedReasonBytes)
             } else {
-              args.privilegedReason = undefined;
+              args.privilegedReason = undefined
             }
 
             // 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
             }
           } else {
             // Deserialize privilege 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) {
               const privilegedReasonBytes = paramsReader.read(
                 privilegedReasonLength
-              );
-              args.privilegedReason = Utils.toUTF8(privilegedReasonBytes);
+              )
+              args.privilegedReason = Utils.toUTF8(privilegedReasonBytes)
             } else {
-              args.privilegedReason = undefined;
+              args.privilegedReason = undefined
             }
           }
 
           // Deserialize seekPermission
-          const seekPermission = paramsReader.readInt8();
+          const seekPermission = paramsReader.readInt8()
           if (seekPermission >= 0) {
-            args.seekPermission = seekPermission === 1;
+            args.seekPermission = seekPermission === 1
           } else {
-            args.seekPermission = undefined;
+            args.seekPermission = undefined
           }
 
           // Call the method
           const getPublicKeyResult = await this.wallet.getPublicKey(
             args,
             originator
-          );
+          )
 
           // Serialize the result
-          const responseWriter = new Utils.Writer();
-          responseWriter.writeUInt8(0); // errorByte = 0
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
           const publicKeyBytes = Utils.toArray(
             getPublicKeyResult.publicKey,
-            "hex"
-          );
-          responseWriter.write(publicKeyBytes);
-          return responseWriter.toArray();
+            'hex'
+          )
+          responseWriter.write(publicKeyBytes)
+          return responseWriter.toArray()
         }
 
-        case "encrypt": {
-          const args: any = this.decodeKeyRelatedParams(paramsReader);
+        case 'encrypt': {
+          const args: any = this.decodeKeyRelatedParams(paramsReader)
 
           // Deserialize plaintext
-          const plaintextLength = paramsReader.readVarIntNum();
-          args.plaintext = paramsReader.read(plaintextLength);
+          const plaintextLength = paramsReader.readVarIntNum()
+          args.plaintext = paramsReader.read(plaintextLength)
 
           // Deserialize seekPermission
-          const seekPermission = paramsReader.readInt8();
+          const seekPermission = paramsReader.readInt8()
           if (seekPermission >= 0) {
-            args.seekPermission = seekPermission === 1;
+            args.seekPermission = seekPermission === 1
           } else {
-            args.seekPermission = undefined;
+            args.seekPermission = undefined
           }
 
           // Call the method
-          const encryptResult = await this.wallet.encrypt(args, originator);
+          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();
+          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);
+        case 'decrypt': {
+          const args: any = this.decodeKeyRelatedParams(paramsReader)
 
           // Deserialize ciphertext
-          const ciphertextLength = paramsReader.readVarIntNum();
-          args.ciphertext = paramsReader.read(ciphertextLength);
+          const ciphertextLength = paramsReader.readVarIntNum()
+          args.ciphertext = paramsReader.read(ciphertextLength)
 
           // Deserialize seekPermission
-          const seekPermission = paramsReader.readInt8();
+          const seekPermission = paramsReader.readInt8()
           if (seekPermission >= 0) {
-            args.seekPermission = seekPermission === 1;
+            args.seekPermission = seekPermission === 1
           } else {
-            args.seekPermission = undefined;
+            args.seekPermission = undefined
           }
 
           // Call the method
-          const decryptResult = await this.wallet.decrypt(args, originator);
+          const decryptResult = await this.wallet.decrypt(args, originator)
 
           // Serialize the result
-          const responseWriter = new Utils.Writer();
-          responseWriter.writeUInt8(0); // errorByte = 0
-          responseWriter.write(decryptResult.plaintext);
-          return responseWriter.toArray();
+          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);
+        case 'createHmac': {
+          const args: any = this.decodeKeyRelatedParams(paramsReader)
 
           // Deserialize data
-          const dataLength = paramsReader.readVarIntNum();
-          args.data = paramsReader.read(dataLength);
+          const dataLength = paramsReader.readVarIntNum()
+          args.data = paramsReader.read(dataLength)
 
           // Deserialize seekPermission
-          const seekPermission = paramsReader.readInt8();
+          const seekPermission = paramsReader.readInt8()
           if (seekPermission >= 0) {
-            args.seekPermission = seekPermission === 1;
+            args.seekPermission = seekPermission === 1
           } else {
-            args.seekPermission = undefined;
+            args.seekPermission = undefined
           }
 
           // 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();
+          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);
+        case 'verifyHmac': {
+          const args: any = this.decodeKeyRelatedParams(paramsReader)
 
           // Deserialize hmac
-          args.hmac = paramsReader.read(32);
+          args.hmac = paramsReader.read(32)
 
           // Deserialize data
-          const dataLength = paramsReader.readVarIntNum();
-          args.data = paramsReader.read(dataLength);
+          const dataLength = paramsReader.readVarIntNum()
+          args.data = paramsReader.read(dataLength)
 
           // Deserialize seekPermission
-          const seekPermission = paramsReader.readInt8();
+          const seekPermission = paramsReader.readInt8()
           if (seekPermission >= 0) {
-            args.seekPermission = seekPermission === 1;
+            args.seekPermission = seekPermission === 1
           } else {
-            args.seekPermission = undefined;
+            args.seekPermission = undefined
           }
 
           // Call the method
-          await this.wallet.verifyHmac(args, originator);
+          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();
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          return responseWriter.toArray()
         }
 
-        case "createSignature": {
-          const args: any = this.decodeKeyRelatedParams(paramsReader);
+        case 'createSignature': {
+          const args: any = this.decodeKeyRelatedParams(paramsReader)
 
           // Deserialize data or hashToDirectlySign
-          const dataTypeFlag = paramsReader.readUInt8();
+          const dataTypeFlag = paramsReader.readUInt8()
           if (dataTypeFlag === 1) {
-            const dataLength = paramsReader.readVarIntNum();
-            args.data = paramsReader.read(dataLength);
+            const dataLength = paramsReader.readVarIntNum()
+            args.data = paramsReader.read(dataLength)
           } else if (dataTypeFlag === 2) {
-            args.hashToDirectlySign = paramsReader.read(32);
+            args.hashToDirectlySign = paramsReader.read(32)
           }
 
           // Deserialize seekPermission
-          const seekPermission = paramsReader.readInt8();
+          const seekPermission = paramsReader.readInt8()
           if (seekPermission >= 0) {
-            args.seekPermission = seekPermission === 1;
+            args.seekPermission = seekPermission === 1
           } else {
-            args.seekPermission = undefined;
+            args.seekPermission = 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();
+          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);
+        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);
+          const signatureLength = paramsReader.readVarIntNum()
+          args.signature = paramsReader.read(signatureLength)
 
           // Deserialize data or hashToDirectlyVerify
-          const dataTypeFlag = paramsReader.readUInt8();
+          const dataTypeFlag = paramsReader.readUInt8()
           if (dataTypeFlag === 1) {
-            const dataLength = paramsReader.readVarIntNum();
-            args.data = paramsReader.read(dataLength);
+            const dataLength = paramsReader.readVarIntNum()
+            args.data = paramsReader.read(dataLength)
           } else if (dataTypeFlag === 2) {
-            args.hashToDirectlyVerify = paramsReader.read(32);
+            args.hashToDirectlyVerify = paramsReader.read(32)
           }
 
           // Deserialize seekPermission
-          const seekPermission = paramsReader.readInt8();
+          const seekPermission = paramsReader.readInt8()
           if (seekPermission >= 0) {
-            args.seekPermission = seekPermission === 1;
+            args.seekPermission = seekPermission === 1
           } else {
-            args.seekPermission = undefined;
+            args.seekPermission = undefined
           }
 
           // Call the method
-          await this.wallet.verifySignature(args, originator);
+          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();
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          return responseWriter.toArray()
         }
 
-        case "isAuthenticated": {
+        case 'isAuthenticated': {
           // No parameters to deserialize
 
           // Call the method
           const isAuthenticatedResult = await this.wallet.isAuthenticated(
             {},
             originator
-          );
+          )
 
           // Serialize the result
-          const responseWriter = new Utils.Writer();
-          responseWriter.writeUInt8(0); // errorByte = 0
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
           responseWriter.writeUInt8(
             isAuthenticatedResult.authenticated ? 1 : 0
-          );
-          return responseWriter.toArray();
+          )
+          return responseWriter.toArray()
         }
 
-        case "waitForAuthentication": {
+        case 'waitForAuthentication': {
           // No parameters to deserialize
 
           // Call the method
-          await this.wallet.waitForAuthentication({}, originator);
+          await this.wallet.waitForAuthentication({}, originator)
 
           // Serialize the result (authenticated is always true)
-          const responseWriter = new Utils.Writer();
-          responseWriter.writeUInt8(0); // errorByte = 0
-          return responseWriter.toArray();
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          return responseWriter.toArray()
         }
 
-        case "getHeight": {
+        case 'getHeight': {
           // No parameters to deserialize
 
           // Call the method
-          const getHeightResult = await this.wallet.getHeight({}, originator);
+          const getHeightResult = await this.wallet.getHeight({}, originator)
 
           // Serialize the result
-          const responseWriter = new Utils.Writer();
-          responseWriter.writeUInt8(0); // errorByte = 0
-          responseWriter.writeVarIntNum(getHeightResult.height);
-          return responseWriter.toArray();
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.writeVarIntNum(getHeightResult.height)
+          return responseWriter.toArray()
         }
 
-        case "getHeaderForHeight": {
-          const args: any = {};
+        case 'getHeaderForHeight': {
+          const args: any = {}
 
           // Deserialize height
-          args.height = paramsReader.readVarIntNum();
+          args.height = paramsReader.readVarIntNum()
 
           // Call the method
           const getHeaderResult = await this.wallet.getHeaderForHeight(
             args,
             originator
-          );
+          )
 
           // 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();
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          const headerBytes = Utils.toArray(getHeaderResult.header, 'hex')
+          responseWriter.write(headerBytes)
+          return responseWriter.toArray()
         }
 
-        case "getNetwork": {
+        case 'getNetwork': {
           // No parameters to deserialize
 
           // Call the method
-          const getNetworkResult = await this.wallet.getNetwork({}, originator);
+          const getNetworkResult = await this.wallet.getNetwork({}, originator)
 
           // Serialize the result
-          const responseWriter = new Utils.Writer();
-          responseWriter.writeUInt8(0); // errorByte = 0
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
           responseWriter.writeUInt8(
-            getNetworkResult.network === "mainnet" ? 0 : 1
-          );
-          return responseWriter.toArray();
+            getNetworkResult.network === 'mainnet' ? 0 : 1
+          )
+          return responseWriter.toArray()
         }
 
-        case "getVersion": {
+        case 'getVersion': {
           // No parameters to deserialize
 
           // Call the method
-          const getVersionResult = await this.wallet.getVersion({}, originator);
+          const getVersionResult = await this.wallet.getVersion({}, originator)
 
           // 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();
+          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 = {};
+        case 'revealCounterpartyKeyLinkage': {
+          const args: any = {}
 
           // 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);
+            )
+            args.privilegedReason = Utils.toUTF8(privilegedReasonBytes)
           }
 
           // Read counterparty public key
-          const counterpartyBytes = paramsReader.read(33);
-          args.counterparty = Utils.toHex(counterpartyBytes);
+          const counterpartyBytes = paramsReader.read(33)
+          args.counterparty = Utils.toHex(counterpartyBytes)
 
           // Read verifier public key
-          const verifierBytes = paramsReader.read(33);
-          args.verifier = Utils.toHex(verifierBytes);
+          const verifierBytes = paramsReader.read(33)
+          args.verifier = Utils.toHex(verifierBytes)
 
           // Call the method
           const revealResult = await this.wallet.revealCounterpartyKeyLinkage(
             args,
             originator
-          );
+          )
 
           // Serialize the result
-          const resultWriter = new Utils.Writer();
+          const resultWriter = new Utils.Writer()
 
           // Write prover
-          resultWriter.write(Utils.toArray(revealResult.prover, "hex"));
+          resultWriter.write(Utils.toArray(revealResult.prover, 'hex'))
 
           // Write verifier
-          resultWriter.write(Utils.toArray(revealResult.verifier, "hex"));
+          resultWriter.write(Utils.toArray(revealResult.verifier, 'hex'))
 
           // Write counterparty
-          resultWriter.write(Utils.toArray(revealResult.counterparty, "hex"));
+          resultWriter.write(Utils.toArray(revealResult.counterparty, 'hex'))
 
           // Write revelationTime
           const revelationTimeBytes = Utils.toArray(
             revealResult.revelationTime,
-            "utf8"
-          );
-          resultWriter.writeVarIntNum(revelationTimeBytes.length);
-          resultWriter.write(revelationTimeBytes);
+            'utf8'
+          )
+          resultWriter.writeVarIntNum(revelationTimeBytes.length)
+          resultWriter.write(revelationTimeBytes)
 
           // Write encryptedLinkage
-          resultWriter.writeVarIntNum(revealResult.encryptedLinkage.length);
-          resultWriter.write(revealResult.encryptedLinkage);
+          resultWriter.writeVarIntNum(revealResult.encryptedLinkage.length)
+          resultWriter.write(revealResult.encryptedLinkage)
 
           // Write encryptedLinkageProof
           resultWriter.writeVarIntNum(
             revealResult.encryptedLinkageProof.length
-          );
-          resultWriter.write(revealResult.encryptedLinkageProof);
+          )
+          resultWriter.write(revealResult.encryptedLinkageProof)
 
           // Return success code and result
-          const responseWriter = new Utils.Writer();
-          responseWriter.writeUInt8(0); // errorByte = 0
-          responseWriter.write(resultWriter.toArray());
-          return responseWriter.toArray();
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.write(resultWriter.toArray())
+          return responseWriter.toArray()
         }
 
-        case "revealSpecificKeyLinkage": {
+        case 'revealSpecificKeyLinkage': {
           // Deserialize key-related parameters and privileged parameters
-          const args = this.decodeKeyRelatedParams(paramsReader);
+          const args = this.decodeKeyRelatedParams(paramsReader)
 
           // Read verifier public key
-          const verifierBytes = paramsReader.read(33);
-          args.verifier = Utils.toHex(verifierBytes);
+          const verifierBytes = paramsReader.read(33)
+          args.verifier = Utils.toHex(verifierBytes)
 
           // Call the method
           const revealResult = await this.wallet.revealSpecificKeyLinkage(
             args,
             originator
-          );
+          )
 
           // Serialize the result
-          const resultWriter = new Utils.Writer();
+          const resultWriter = new Utils.Writer()
 
           // Write prover
-          resultWriter.write(Utils.toArray(revealResult.prover, "hex"));
+          resultWriter.write(Utils.toArray(revealResult.prover, 'hex'))
 
           // Write verifier
-          resultWriter.write(Utils.toArray(revealResult.verifier, "hex"));
+          resultWriter.write(Utils.toArray(revealResult.verifier, 'hex'))
 
           // Write counterparty
-          resultWriter.write(Utils.toArray(revealResult.counterparty, "hex"));
+          resultWriter.write(Utils.toArray(revealResult.counterparty, 'hex'))
 
           // Write securityLevel
-          resultWriter.writeUInt8(revealResult.protocolID[0]);
+          resultWriter.writeUInt8(revealResult.protocolID[0])
 
           // Write protocol string
           const protocolBytesOut = Utils.toArray(
             revealResult.protocolID[1],
-            "utf8"
-          );
-          resultWriter.writeVarIntNum(protocolBytesOut.length);
-          resultWriter.write(protocolBytesOut);
+            'utf8'
+          )
+          resultWriter.writeVarIntNum(protocolBytesOut.length)
+          resultWriter.write(protocolBytesOut)
 
           // Write keyID
-          const keyIDBytesOut = Utils.toArray(revealResult.keyID, "utf8");
-          resultWriter.writeVarIntNum(keyIDBytesOut.length);
-          resultWriter.write(keyIDBytesOut);
+          const keyIDBytesOut = Utils.toArray(revealResult.keyID, 'utf8')
+          resultWriter.writeVarIntNum(keyIDBytesOut.length)
+          resultWriter.write(keyIDBytesOut)
 
           // Write encryptedLinkage
-          resultWriter.writeVarIntNum(revealResult.encryptedLinkage.length);
-          resultWriter.write(revealResult.encryptedLinkage);
+          resultWriter.writeVarIntNum(revealResult.encryptedLinkage.length)
+          resultWriter.write(revealResult.encryptedLinkage)
 
           // Write encryptedLinkageProof
           resultWriter.writeVarIntNum(
             revealResult.encryptedLinkageProof.length
-          );
-          resultWriter.write(revealResult.encryptedLinkageProof);
+          )
+          resultWriter.write(revealResult.encryptedLinkageProof)
 
           // Write proofType
-          resultWriter.writeUInt8(revealResult.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();
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.write(resultWriter.toArray())
+          return responseWriter.toArray()
         }
 
-        case "acquireCertificate": {
-          const args: any = {};
+        case 'acquireCertificate': {
+          const args: any = {}
 
           // Read args.type
-          const typeBytes = paramsReader.read(32);
-          args.type = Utils.toBase64(typeBytes);
+          const typeBytes = paramsReader.read(32)
+          args.type = Utils.toBase64(typeBytes)
 
           // args.certifier
-          const certifierBytes = paramsReader.read(33);
-          args.certifier = Utils.toHex(certifierBytes);
+          const certifierBytes = paramsReader.read(33)
+          args.certifier = Utils.toHex(certifierBytes)
 
           // Read fields
-          const fieldsLength = paramsReader.readVarIntNum();
-          args.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 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);
+            const fieldValueLength = paramsReader.readVarIntNum()
+            const fieldValueBytes = paramsReader.read(fieldValueLength)
+            const fieldValue = Utils.toUTF8(fieldValueBytes)
 
-            args.fields[fieldName] = fieldValue;
+            args.fields[fieldName] = fieldValue
           }
 
           // 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);
+            )
+            args.privilegedReason = Utils.toUTF8(privilegedReasonBytes)
           }
 
           // Read acquisitionProtocol
-          const acquisitionProtocolFlag = paramsReader.readUInt8();
+          const acquisitionProtocolFlag = paramsReader.readUInt8()
           args.acquisitionProtocol =
-            acquisitionProtocolFlag === 1 ? "direct" : "issuance";
+            acquisitionProtocolFlag === 1 ? 'direct' : 'issuance'
 
-          if (args.acquisitionProtocol === "direct") {
+          if (args.acquisitionProtocol === 'direct') {
             // args.serialNumber
-            const serialNumberBytes = paramsReader.read(32);
-            args.serialNumber = Utils.toBase64(serialNumberBytes);
+            const serialNumberBytes = paramsReader.read(32)
+            args.serialNumber = Utils.toBase64(serialNumberBytes)
 
             // args.revocationOutpoint
-            args.revocationOutpoint = this.decodeOutpoint(paramsReader);
+            args.revocationOutpoint = this.decodeOutpoint(paramsReader)
 
             // args.signature
-            const signatureLength = paramsReader.readVarIntNum();
-            const signatureBytes = paramsReader.read(signatureLength);
-            args.signature = Utils.toHex(signatureBytes);
+            const signatureLength = paramsReader.readVarIntNum()
+            const signatureBytes = paramsReader.read(signatureLength)
+            args.signature = Utils.toHex(signatureBytes)
 
             // args.keyringRevealer
-            const keyringRevealerIdentifier = paramsReader.readUInt8();
+            const keyringRevealerIdentifier = paramsReader.readUInt8()
             if (keyringRevealerIdentifier === 11) {
-              args.keyringRevealer = "certifier";
+              args.keyringRevealer = 'certifier'
             } else {
               const keyringRevealerBytes = [keyringRevealerIdentifier].concat(
                 paramsReader.read(32)
-              );
-              args.keyringRevealer = Utils.toHex(keyringRevealerBytes);
+              )
+              args.keyringRevealer = Utils.toHex(keyringRevealerBytes)
             }
 
             // args.keyringForSubject
-            const keyringEntriesLength = paramsReader.readVarIntNum();
-            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 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.toBase64(fieldValueBytes);
+              const fieldValueLength = paramsReader.readVarIntNum()
+              const fieldValueBytes = paramsReader.read(fieldValueLength)
+              const fieldValue = Utils.toBase64(fieldValueBytes)
 
-              args.keyringForSubject[fieldKey] = fieldValue;
+              args.keyringForSubject[fieldKey] = fieldValue
             }
           } else {
             // args.certifierUrl
-            const certifierUrlLength = paramsReader.readVarIntNum();
-            const certifierUrlBytes = paramsReader.read(certifierUrlLength);
-            args.certifierUrl = Utils.toUTF8(certifierUrlBytes);
+            const certifierUrlLength = paramsReader.readVarIntNum()
+            const certifierUrlBytes = paramsReader.read(certifierUrlLength)
+            args.certifierUrl = Utils.toUTF8(certifierUrlBytes)
           }
 
           // Call the method
           const acquireResult = await this.wallet.acquireCertificate(
             args,
             originator
-          );
+          )
 
           // Serialize the certificate (assuming Certificate class is available)
           const cert = new Certificate(
@@ -1690,79 +1689,79 @@ export default class WalletWireProcessor implements WalletWire {
             acquireResult.revocationOutpoint,
             acquireResult.fields,
             acquireResult.signature
-          );
-          const certBin = cert.toBinary();
+          )
+          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();
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.write(certBin)
+          return responseWriter.toArray()
         }
 
-        case "listCertificates": {
-          const args: any = {};
+        case 'listCertificates': {
+          const args: any = {}
 
           // Read certifiers
-          const certifiersLength = paramsReader.readVarIntNum();
-          args.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));
+            const certifierBytes = paramsReader.read(33)
+            args.certifiers.push(Utils.toHex(certifierBytes))
           }
 
           // Read types
-          const typesLength = paramsReader.readVarIntNum();
-          args.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));
+            const typeBytes = paramsReader.read(32)
+            args.types.push(Utils.toBase64(typeBytes))
           }
 
           // Read limit and offset
-          const limit = paramsReader.readVarIntNum();
+          const limit = paramsReader.readVarIntNum()
           if (limit >= 0) {
-            args.limit = limit;
+            args.limit = limit
           } else {
-            args.limit = undefined;
+            args.limit = undefined
           }
 
-          const offset = paramsReader.readVarIntNum();
+          const offset = paramsReader.readVarIntNum()
           if (offset >= 0) {
-            args.offset = offset;
+            args.offset = offset
           } else {
-            args.offset = undefined;
+            args.offset = undefined
           }
 
           // 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);
+            )
+            args.privilegedReason = Utils.toUTF8(privilegedReasonBytes)
           }
 
           // Call the method
           const listResult = await this.wallet.listCertificates(
             args,
             originator
-          );
+          )
 
           // Serialize the result
-          const resultWriter = new Utils.Writer();
+          const resultWriter = new Utils.Writer()
 
           // totalCertificates
-          resultWriter.writeVarIntNum(listResult.totalCertificates);
+          resultWriter.writeVarIntNum(listResult.totalCertificates)
 
           // certificates
           for (const cert of listResult.certificates) {
@@ -1774,313 +1773,313 @@ export default class WalletWireProcessor implements WalletWire {
               cert.revocationOutpoint,
               cert.fields,
               cert.signature
-            );
-            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)
           }
 
           // Return the response
-          const responseWriter = new Utils.Writer();
-          responseWriter.writeUInt8(0); // errorByte = 0
-          responseWriter.write(resultWriter.toArray());
-          return responseWriter.toArray();
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.write(resultWriter.toArray())
+          return responseWriter.toArray()
         }
 
-        case "proveCertificate": {
-          const args: any = {};
+        case 'proveCertificate': {
+          const args: any = {}
 
           // Read certificate
-          const cert: any = {};
+          const cert: any = {}
 
           // Read type
-          const typeBytes = paramsReader.read(32);
-          cert.type = Utils.toBase64(typeBytes);
+          const typeBytes = paramsReader.read(32)
+          cert.type = Utils.toBase64(typeBytes)
 
           // Read subject
-          const subjectBytes = paramsReader.read(33);
-          cert.subject = Utils.toHex(subjectBytes);
+          const subjectBytes = paramsReader.read(33)
+          cert.subject = Utils.toHex(subjectBytes)
 
           // Read serialNumber
-          const serialNumberBytes = paramsReader.read(32);
-          cert.serialNumber = Utils.toBase64(serialNumberBytes);
+          const serialNumberBytes = paramsReader.read(32)
+          cert.serialNumber = Utils.toBase64(serialNumberBytes)
 
           // Read certifier
-          const certifierBytes = paramsReader.read(33);
-          cert.certifier = Utils.toHex(certifierBytes);
+          const certifierBytes = paramsReader.read(33)
+          cert.certifier = Utils.toHex(certifierBytes)
 
           // Read revocationOutpoint
-          cert.revocationOutpoint = this.decodeOutpoint(paramsReader);
+          cert.revocationOutpoint = this.decodeOutpoint(paramsReader)
 
           // Read signature
-          const signatureLength = paramsReader.readVarIntNum();
-          const signatureBytes = paramsReader.read(signatureLength);
-          cert.signature = Utils.toHex(signatureBytes);
+          const signatureLength = paramsReader.readVarIntNum()
+          const signatureBytes = paramsReader.read(signatureLength)
+          cert.signature = Utils.toHex(signatureBytes)
 
           // Read fields
-          const fieldsLength = paramsReader.readVarIntNum();
-          cert.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);
+            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);
+            const fieldValueLength = paramsReader.readVarIntNum()
+            const fieldValueBytes = paramsReader.read(fieldValueLength)
+            const fieldValue = Utils.toUTF8(fieldValueBytes)
 
-            cert.fields[fieldName] = fieldValue;
+            cert.fields[fieldName] = fieldValue
           }
 
-          args.certificate = cert;
+          args.certificate = cert
 
           // Read fields to reveal
-          const fieldsToRevealLength = paramsReader.readVarIntNum();
-          args.fieldsToReveal = [];
+          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);
+            const fieldNameLength = paramsReader.readVarIntNum()
+            const fieldNameBytes = paramsReader.read(fieldNameLength)
+            const fieldName = Utils.toUTF8(fieldNameBytes)
+            args.fieldsToReveal.push(fieldName)
           }
 
           // Read verifier
-          const verifierBytes = paramsReader.read(33);
-          args.verifier = Utils.toHex(verifierBytes);
+          const verifierBytes = paramsReader.read(33)
+          args.verifier = Utils.toHex(verifierBytes)
 
           // 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);
+            )
+            args.privilegedReason = Utils.toUTF8(privilegedReasonBytes)
           }
 
           // Call the method
           const proveResult = await this.wallet.proveCertificate(
             args,
             originator
-          );
+          )
 
           // Serialize keyringForVerifier
-          const resultWriter = new Utils.Writer();
+          const resultWriter = new Utils.Writer()
 
-          const keyringEntries = Object.entries(proveResult.keyringForVerifier);
-          resultWriter.writeVarIntNum(keyringEntries.length);
+          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 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)
           }
 
           // Return the response
-          const responseWriter = new Utils.Writer();
-          responseWriter.writeUInt8(0); // errorByte = 0
-          responseWriter.write(resultWriter.toArray());
-          return responseWriter.toArray();
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.write(resultWriter.toArray())
+          return responseWriter.toArray()
         }
 
-        case "relinquishCertificate": {
-          const args: any = {};
+        case 'relinquishCertificate': {
+          const args: any = {}
 
           // Read type
-          const typeBytes = paramsReader.read(32);
-          args.type = Utils.toBase64(typeBytes);
+          const typeBytes = paramsReader.read(32)
+          args.type = Utils.toBase64(typeBytes)
 
           // Read serialNumber
-          const serialNumberBytes = paramsReader.read(32);
-          args.serialNumber = Utils.toBase64(serialNumberBytes);
+          const serialNumberBytes = paramsReader.read(32)
+          args.serialNumber = Utils.toBase64(serialNumberBytes)
 
           // Read certifier
-          const certifierBytes = paramsReader.read(33);
-          args.certifier = Utils.toHex(certifierBytes);
+          const certifierBytes = paramsReader.read(33)
+          args.certifier = Utils.toHex(certifierBytes)
 
           // Call the method
-          await this.wallet.relinquishCertificate(args, originator);
+          await this.wallet.relinquishCertificate(args, originator)
 
           // Return success code
-          const responseWriter = new Utils.Writer();
-          responseWriter.writeUInt8(0); // errorByte = 0
-          return responseWriter.toArray();
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          return responseWriter.toArray()
         }
 
-        case "discoverByIdentityKey": {
-          const args: any = {};
+        case 'discoverByIdentityKey': {
+          const args: any = {}
 
           // Read identityKey
-          const identityKeyBytes = paramsReader.read(33);
-          args.identityKey = Utils.toHex(identityKeyBytes);
+          const identityKeyBytes = paramsReader.read(33)
+          args.identityKey = Utils.toHex(identityKeyBytes)
 
           // Read limit and offset
-          const limit = paramsReader.readVarIntNum();
+          const limit = paramsReader.readVarIntNum()
           if (limit >= 0) {
-            args.limit = limit;
+            args.limit = limit
           } else {
-            args.limit = undefined;
+            args.limit = undefined
           }
 
-          const offset = paramsReader.readVarIntNum();
+          const offset = paramsReader.readVarIntNum()
           if (offset >= 0) {
-            args.offset = offset;
+            args.offset = offset
           } else {
-            args.offset = undefined;
+            args.offset = undefined
           }
 
           // Deserialize seekPermission
-          const seekPermission = paramsReader.readInt8();
+          const seekPermission = paramsReader.readInt8()
           if (seekPermission >= 0) {
-            args.seekPermission = seekPermission === 1;
+            args.seekPermission = seekPermission === 1
           } else {
-            args.seekPermission = undefined;
+            args.seekPermission = undefined
           }
 
           // Call the method
           const discoverResult = await this.wallet.discoverByIdentityKey(
             args,
             originator
-          );
+          )
 
           // Serialize the result
-          const result = this.serializeDiscoveryResult(discoverResult);
+          const result = this.serializeDiscoveryResult(discoverResult)
 
           // Return the response
-          const responseWriter = new Utils.Writer();
-          responseWriter.writeUInt8(0); // errorByte = 0
-          responseWriter.write(result);
-          return responseWriter.toArray();
+          const responseWriter = new Utils.Writer()
+          responseWriter.writeUInt8(0) // errorByte = 0
+          responseWriter.write(result)
+          return responseWriter.toArray()
         }
 
-        case "discoverByAttributes": {
-          const args: any = {};
+        case 'discoverByAttributes': {
+          const args: any = {}
 
           // Read attributes
-          const attributesLength = paramsReader.readVarIntNum();
-          args.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 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);
+            const fieldValueLength = paramsReader.readVarIntNum()
+            const fieldValueBytes = paramsReader.read(fieldValueLength)
+            const fieldValue = Utils.toUTF8(fieldValueBytes)
 
-            args.attributes[fieldKey] = fieldValue;
+            args.attributes[fieldKey] = fieldValue
           }
 
           // Read limit and offset
-          const limit = paramsReader.readVarIntNum();
+          const limit = paramsReader.readVarIntNum()
           if (limit >= 0) {
-            args.limit = limit;
+            args.limit = limit
           } else {
-            args.limit = undefined;
+            args.limit = undefined
           }
 
-          const offset = paramsReader.readVarIntNum();
+          const offset = paramsReader.readVarIntNum()
           if (offset >= 0) {
-            args.offset = offset;
+            args.offset = offset
           } else {
-            args.offset = undefined;
+            args.offset = undefined
           }
 
           // Deserialize seekPermission
-          const seekPermission = paramsReader.readInt8();
+          const seekPermission = paramsReader.readInt8()
           if (seekPermission >= 0) {
-            args.seekPermission = seekPermission === 1;
+            args.seekPermission = seekPermission === 1
           } else {
-            args.seekPermission = undefined;
+            args.seekPermission = undefined
           }
 
           // Call the method
           const discoverResult = await this.wallet.discoverByAttributes(
             args,
             originator
-          );
+          )
 
           // Serialize the result
-          const result = this.serializeDiscoveryResult(discoverResult);
+          const result = this.serializeDiscoveryResult(discoverResult)
 
           // Return the response
-          const responseWriter = new Utils.Writer();
-          responseWriter.writeUInt8(0); // errorByte = 0
-          responseWriter.write(result);
-          return responseWriter.toArray();
+          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(typeof err.code === 'number' ? 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 = typeof err.message === 'string' ? err.message : 'Unknown error'
+      const errorMessageBytes = Utils.toArray(errorMessage, 'utf8')
+      responseWriter.writeVarIntNum(errorMessageBytes.length)
+      responseWriter.write(errorMessageBytes)
 
       // Serialize the stack trace
-      const stackTrace = err.stack || "";
-      const stackTraceBytes = Utils.toArray(stackTrace, "utf8");
-      responseWriter.writeVarIntNum(stackTraceBytes.length);
-      responseWriter.write(stackTraceBytes);
+      const stackTrace = typeof err.stack === 'string' ? 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();
+  ): 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) {
@@ -2093,91 +2092,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);
+        '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
   }
 }