@bsv/sdk 1.3.12 → 1.3.13

package/src/wallet/substrates/WalletWireTransceiver.ts

@@ -1,469 +1,553 @@
-import { AcquireCertificateArgs, AcquireCertificateResult, SecurityLevel, Base64String, BasketStringUnder300Bytes, BEEF, BooleanDefaultFalse, BooleanDefaultTrue, Byte, CertificateFieldNameUnder50Bytes, CreateActionArgs, CreateActionResult, DescriptionString5to50Bytes, DiscoverCertificatesResult, EntityIconURLStringMax500Bytes, EntityNameStringMax100Bytes, HexString, InternalizeActionArgs, ISOTimestampString, KeyIDStringUnder800Bytes, LabelStringUnder300Bytes, ListActionsArgs, ListActionsResult, ListCertificatesResult, ListOutputsArgs, ListOutputsResult, OriginatorDomainNameStringUnder250Bytes, OutpointString, OutputTagStringUnder300Bytes, PositiveInteger, PositiveIntegerDefault10Max10000, PositiveIntegerMax10, PositiveIntegerOrZero, ProtocolString5To400Bytes, ProveCertificateArgs, ProveCertificateResult, PubKeyHex, SatoshiValue, SignActionArgs, SignActionResult, TXIDHexString, VersionString7To30Bytes, WalletInterface } from '../Wallet.interfaces.js'
-import WalletWire from './WalletWire.js'
-import { Certificate } from '../../auth/index.js'
-import { Utils } from '../../primitives/index.js'
-import calls, { CallType } from './WalletWireCalls.js'
-import { WalletError } from '../WalletError.js'
+import {
+  AcquireCertificateArgs,
+  AcquireCertificateResult,
+  SecurityLevel,
+  Base64String,
+  BasketStringUnder300Bytes,
+  BEEF,
+  BooleanDefaultFalse,
+  BooleanDefaultTrue,
+  Byte,
+  CertificateFieldNameUnder50Bytes,
+  CreateActionArgs,
+  CreateActionResult,
+  DescriptionString5to50Bytes,
+  DiscoverCertificatesResult,
+  EntityIconURLStringMax500Bytes,
+  EntityNameStringMax100Bytes,
+  HexString,
+  InternalizeActionArgs,
+  ISOTimestampString,
+  KeyIDStringUnder800Bytes,
+  LabelStringUnder300Bytes,
+  ListActionsArgs,
+  ListActionsResult,
+  ListCertificatesResult,
+  ListOutputsArgs,
+  ListOutputsResult,
+  OriginatorDomainNameStringUnder250Bytes,
+  OutpointString,
+  OutputTagStringUnder300Bytes,
+  PositiveInteger,
+  PositiveIntegerDefault10Max10000,
+  PositiveIntegerMax10,
+  PositiveIntegerOrZero,
+  ProtocolString5To400Bytes,
+  ProveCertificateArgs,
+  ProveCertificateResult,
+  PubKeyHex,
+  SatoshiValue,
+  SignActionArgs,
+  SignActionResult,
+  TXIDHexString,
+  VersionString7To30Bytes,
+  WalletInterface,
+} from "../Wallet.interfaces";
+import WalletWire from "./WalletWire";
+import { Certificate } from "../../auth/index";
+import { Utils } from "../../primitives/index";
+import calls, { CallType } from "./WalletWireCalls";
+import { WalletError } from "../WalletError";
 
 /**
  * A way to make remote calls to a wallet over a wallet wire.
  */
 export default class WalletWireTransceiver implements WalletInterface {
-  wire: WalletWire
+  wire: WalletWire;
 
   constructor(wire: WalletWire) {
-    this.wire = wire
+    this.wire = wire;
   }
 
-  private async transmit(call: CallType, originator: OriginatorDomainNameStringUnder250Bytes = '', params: number[] = []): Promise<number[]> {
-    const frameWriter = new Utils.Writer()
-    frameWriter.writeUInt8(calls[call])
-    const originatorArray = Utils.toArray(originator, 'utf8')
-    frameWriter.writeUInt8(originatorArray.length)
-    frameWriter.write(originatorArray)
+  private async transmit(
+    call: CallType,
+    originator: OriginatorDomainNameStringUnder250Bytes = "",
+    params: number[] = []
+  ): Promise<number[]> {
+    const frameWriter = new Utils.Writer();
+    frameWriter.writeUInt8(calls[call]);
+    const originatorArray = Utils.toArray(originator, "utf8");
+    frameWriter.writeUInt8(originatorArray.length);
+    frameWriter.write(originatorArray);
     if (params.length > 0) {
-      frameWriter.write(params)
+      frameWriter.write(params);
     }
-    const frame = frameWriter.toArray()
-    const result = await this.wire.transmitToWallet(frame)
-    const resultReader = new Utils.Reader(result)
-    const errorByte = resultReader.readUInt8()
+    const frame = frameWriter.toArray();
+    const result = await this.wire.transmitToWallet(frame);
+    const resultReader = new Utils.Reader(result);
+    const errorByte = resultReader.readUInt8();
     if (errorByte === 0) {
-      const resultFrame = resultReader.read()
-      return resultFrame
+      const resultFrame = resultReader.read();
+      return resultFrame;
     } else {
       // Deserialize the error message length
-      const errorMessageLength = resultReader.readVarIntNum()
-      const errorMessageBytes = resultReader.read(errorMessageLength)
-      const errorMessage = Utils.toUTF8(errorMessageBytes)
+      const errorMessageLength = resultReader.readVarIntNum();
+      const errorMessageBytes = resultReader.read(errorMessageLength);
+      const errorMessage = Utils.toUTF8(errorMessageBytes);
 
       // Deserialize the stack trace length
-      const stackTraceLength = resultReader.readVarIntNum()
-      const stackTraceBytes = resultReader.read(stackTraceLength)
-      const stackTrace = Utils.toUTF8(stackTraceBytes)
+      const stackTraceLength = resultReader.readVarIntNum();
+      const stackTraceBytes = resultReader.read(stackTraceLength);
+      const stackTrace = Utils.toUTF8(stackTraceBytes);
 
       // Construct a custom wallet error
-      const e = new WalletError(errorMessage, errorByte, stackTrace)
-      throw e
+      const e = new WalletError(errorMessage, errorByte, stackTrace);
+      throw e;
     }
   }
 
-  async createAction(args: CreateActionArgs, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<CreateActionResult> {
-    const paramWriter = new Utils.Writer()
+  async createAction(
+    args: CreateActionArgs,
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<CreateActionResult> {
+    const paramWriter = new Utils.Writer();
 
     // Serialize description
-    const descriptionBytes = Utils.toArray(args.description, 'utf8')
-    paramWriter.writeVarIntNum(descriptionBytes.length)
-    paramWriter.write(descriptionBytes)
+    const descriptionBytes = Utils.toArray(args.description, "utf8");
+    paramWriter.writeVarIntNum(descriptionBytes.length);
+    paramWriter.write(descriptionBytes);
 
     // input BEEF
     if (args.inputBEEF) {
-      paramWriter.writeVarIntNum(args.inputBEEF.length)
-      paramWriter.write(args.inputBEEF)
+      paramWriter.writeVarIntNum(args.inputBEEF.length);
+      paramWriter.write(args.inputBEEF);
     } else {
-      paramWriter.writeVarIntNum(-1)
+      paramWriter.writeVarIntNum(-1);
     }
 
     // Serialize inputs
     if (args.inputs) {
-      paramWriter.writeVarIntNum(args.inputs.length)
+      paramWriter.writeVarIntNum(args.inputs.length);
       for (const input of args.inputs) {
         // outpoint
-        paramWriter.write(this.encodeOutpoint(input.outpoint))
+        paramWriter.write(this.encodeOutpoint(input.outpoint));
 
         // unlockingScript / unlockingScriptLength
         if (input.unlockingScript) {
-          const unlockingScriptBytes = Utils.toArray(input.unlockingScript, 'hex')
-          paramWriter.writeVarIntNum(unlockingScriptBytes.length)
-          paramWriter.write(unlockingScriptBytes)
+          const unlockingScriptBytes = Utils.toArray(
+            input.unlockingScript,
+            "hex"
+          );
+          paramWriter.writeVarIntNum(unlockingScriptBytes.length);
+          paramWriter.write(unlockingScriptBytes);
         } else {
-          paramWriter.writeVarIntNum(-1)
-          paramWriter.writeVarIntNum(input.unlockingScriptLength)
+          paramWriter.writeVarIntNum(-1);
+          paramWriter.writeVarIntNum(input.unlockingScriptLength);
         }
 
         // inputDescription
-        const inputDescriptionBytes = Utils.toArray(input.inputDescription, 'utf8')
-        paramWriter.writeVarIntNum(inputDescriptionBytes.length)
-        paramWriter.write(inputDescriptionBytes)
+        const inputDescriptionBytes = Utils.toArray(
+          input.inputDescription,
+          "utf8"
+        );
+        paramWriter.writeVarIntNum(inputDescriptionBytes.length);
+        paramWriter.write(inputDescriptionBytes);
 
         // sequenceNumber
-        if (typeof input.sequenceNumber === 'number') {
-          paramWriter.writeVarIntNum(input.sequenceNumber)
+        if (typeof input.sequenceNumber === "number") {
+          paramWriter.writeVarIntNum(input.sequenceNumber);
         } else {
-          paramWriter.writeVarIntNum(-1)
+          paramWriter.writeVarIntNum(-1);
         }
       }
     } else {
-      paramWriter.writeVarIntNum(-1)
+      paramWriter.writeVarIntNum(-1);
     }
 
     // Serialize outputs
     if (args.outputs) {
-      paramWriter.writeVarIntNum(args.outputs.length)
+      paramWriter.writeVarIntNum(args.outputs.length);
       for (const output of args.outputs) {
         // lockingScript
-        const lockingScriptBytes = Utils.toArray(output.lockingScript, 'hex')
-        paramWriter.writeVarIntNum(lockingScriptBytes.length)
-        paramWriter.write(lockingScriptBytes)
+        const lockingScriptBytes = Utils.toArray(output.lockingScript, "hex");
+        paramWriter.writeVarIntNum(lockingScriptBytes.length);
+        paramWriter.write(lockingScriptBytes);
 
         // satoshis
-        paramWriter.writeVarIntNum(output.satoshis)
+        paramWriter.writeVarIntNum(output.satoshis);
 
         // outputDescription
-        const outputDescriptionBytes = Utils.toArray(output.outputDescription, 'utf8')
-        paramWriter.writeVarIntNum(outputDescriptionBytes.length)
-        paramWriter.write(outputDescriptionBytes)
+        const outputDescriptionBytes = Utils.toArray(
+          output.outputDescription,
+          "utf8"
+        );
+        paramWriter.writeVarIntNum(outputDescriptionBytes.length);
+        paramWriter.write(outputDescriptionBytes);
 
         // basket
         if (output.basket) {
-          const basketBytes = Utils.toArray(output.basket, 'utf8')
-          paramWriter.writeVarIntNum(basketBytes.length)
-          paramWriter.write(basketBytes)
+          const basketBytes = Utils.toArray(output.basket, "utf8");
+          paramWriter.writeVarIntNum(basketBytes.length);
+          paramWriter.write(basketBytes);
         } else {
-          paramWriter.writeVarIntNum(-1)
+          paramWriter.writeVarIntNum(-1);
         }
 
         // customInstructions
         if (output.customInstructions) {
-          const customInstructionsBytes = Utils.toArray(output.customInstructions, 'utf8')
-          paramWriter.writeVarIntNum(customInstructionsBytes.length)
-          paramWriter.write(customInstructionsBytes)
+          const customInstructionsBytes = Utils.toArray(
+            output.customInstructions,
+            "utf8"
+          );
+          paramWriter.writeVarIntNum(customInstructionsBytes.length);
+          paramWriter.write(customInstructionsBytes);
         } else {
-          paramWriter.writeVarIntNum(-1)
+          paramWriter.writeVarIntNum(-1);
         }
 
         // tags
         if (output.tags) {
-          paramWriter.writeVarIntNum(output.tags.length)
+          paramWriter.writeVarIntNum(output.tags.length);
           for (const tag of output.tags) {
-            const tagBytes = Utils.toArray(tag, 'utf8')
-            paramWriter.writeVarIntNum(tagBytes.length)
-            paramWriter.write(tagBytes)
+            const tagBytes = Utils.toArray(tag, "utf8");
+            paramWriter.writeVarIntNum(tagBytes.length);
+            paramWriter.write(tagBytes);
           }
         } else {
-          paramWriter.writeVarIntNum(-1)
+          paramWriter.writeVarIntNum(-1);
         }
       }
     } else {
-      paramWriter.writeVarIntNum(-1)
+      paramWriter.writeVarIntNum(-1);
     }
 
     // Serialize lockTime
-    if (typeof args.lockTime === 'number') {
-      paramWriter.writeVarIntNum(args.lockTime)
+    if (typeof args.lockTime === "number") {
+      paramWriter.writeVarIntNum(args.lockTime);
     } else {
-      paramWriter.writeVarIntNum(-1)
+      paramWriter.writeVarIntNum(-1);
     }
 
     // Serialize version
-    if (typeof args.version === 'number') {
-      paramWriter.writeVarIntNum(args.version)
+    if (typeof args.version === "number") {
+      paramWriter.writeVarIntNum(args.version);
     } else {
-      paramWriter.writeVarIntNum(-1)
+      paramWriter.writeVarIntNum(-1);
     }
 
     // Serialize labels
     if (args.labels) {
-      paramWriter.writeVarIntNum(args.labels.length)
+      paramWriter.writeVarIntNum(args.labels.length);
       for (const label of args.labels) {
-        const labelBytes = Utils.toArray(label, 'utf8')
-        paramWriter.writeVarIntNum(labelBytes.length)
-        paramWriter.write(labelBytes)
+        const labelBytes = Utils.toArray(label, "utf8");
+        paramWriter.writeVarIntNum(labelBytes.length);
+        paramWriter.write(labelBytes);
       }
     } else {
-      paramWriter.writeVarIntNum(-1)
+      paramWriter.writeVarIntNum(-1);
     }
 
     // Serialize options
     if (args.options) {
-      paramWriter.writeInt8(1) // options present
+      paramWriter.writeInt8(1); // options present
 
       // signAndProcess
-      if (typeof args.options.signAndProcess === 'boolean') {
-        paramWriter.writeInt8(args.options.signAndProcess ? 1 : 0)
+      if (typeof args.options.signAndProcess === "boolean") {
+        paramWriter.writeInt8(args.options.signAndProcess ? 1 : 0);
       } else {
-        paramWriter.writeInt8(-1)
+        paramWriter.writeInt8(-1);
       }
 
       // acceptDelayedBroadcast
-      if (typeof args.options.acceptDelayedBroadcast === 'boolean') {
-        paramWriter.writeInt8(args.options.acceptDelayedBroadcast ? 1 : 0)
+      if (typeof args.options.acceptDelayedBroadcast === "boolean") {
+        paramWriter.writeInt8(args.options.acceptDelayedBroadcast ? 1 : 0);
       } else {
-        paramWriter.writeInt8(-1)
+        paramWriter.writeInt8(-1);
       }
 
       // trustSelf
-      if (args.options.trustSelf === 'known') {
-        paramWriter.writeInt8(1)
+      if (args.options.trustSelf === "known") {
+        paramWriter.writeInt8(1);
       } else {
-        paramWriter.writeInt8(-1)
+        paramWriter.writeInt8(-1);
       }
 
       // knownTxids
       if (args.options.knownTxids) {
-        paramWriter.writeVarIntNum(args.options.knownTxids.length)
+        paramWriter.writeVarIntNum(args.options.knownTxids.length);
         for (const txid of args.options.knownTxids) {
-          const txidBytes = Utils.toArray(txid, 'hex')
-          paramWriter.write(txidBytes)
+          const txidBytes = Utils.toArray(txid, "hex");
+          paramWriter.write(txidBytes);
         }
       } else {
-        paramWriter.writeVarIntNum(-1)
+        paramWriter.writeVarIntNum(-1);
       }
 
       // returnTXIDOnly
-      if (typeof args.options.returnTXIDOnly === 'boolean') {
-        paramWriter.writeInt8(args.options.returnTXIDOnly ? 1 : 0)
+      if (typeof args.options.returnTXIDOnly === "boolean") {
+        paramWriter.writeInt8(args.options.returnTXIDOnly ? 1 : 0);
       } else {
-        paramWriter.writeInt8(-1)
+        paramWriter.writeInt8(-1);
       }
 
       // noSend
-      if (typeof args.options.noSend === 'boolean') {
-        paramWriter.writeInt8(args.options.noSend ? 1 : 0)
+      if (typeof args.options.noSend === "boolean") {
+        paramWriter.writeInt8(args.options.noSend ? 1 : 0);
       } else {
-        paramWriter.writeInt8(-1)
+        paramWriter.writeInt8(-1);
       }
 
       // noSendChange
       if (args.options.noSendChange) {
-        paramWriter.writeVarIntNum(args.options.noSendChange.length)
+        paramWriter.writeVarIntNum(args.options.noSendChange.length);
         for (const outpoint of args.options.noSendChange) {
-          paramWriter.write(this.encodeOutpoint(outpoint))
+          paramWriter.write(this.encodeOutpoint(outpoint));
         }
       } else {
-        paramWriter.writeVarIntNum(-1)
+        paramWriter.writeVarIntNum(-1);
       }
 
       // sendWith
       if (args.options.sendWith) {
-        paramWriter.writeVarIntNum(args.options.sendWith.length)
+        paramWriter.writeVarIntNum(args.options.sendWith.length);
         for (const txid of args.options.sendWith) {
-          const txidBytes = Utils.toArray(txid, 'hex')
-          paramWriter.write(txidBytes)
+          const txidBytes = Utils.toArray(txid, "hex");
+          paramWriter.write(txidBytes);
         }
       } else {
-        paramWriter.writeVarIntNum(-1)
+        paramWriter.writeVarIntNum(-1);
       }
 
       // randomizeOutputs
-      if (typeof args.options.randomizeOutputs === 'boolean') {
-        paramWriter.writeInt8(args.options.randomizeOutputs ? 1 : 0)
+      if (typeof args.options.randomizeOutputs === "boolean") {
+        paramWriter.writeInt8(args.options.randomizeOutputs ? 1 : 0);
       } else {
-        paramWriter.writeInt8(-1)
+        paramWriter.writeInt8(-1);
       }
     } else {
-      paramWriter.writeInt8(0) // options not present
+      paramWriter.writeInt8(0); // options not present
     }
 
     // Transmit and parse response
-    const result = await this.transmit('createAction', originator, paramWriter.toArray())
-    const resultReader = new Utils.Reader(result)
+    const result = await this.transmit(
+      "createAction",
+      originator,
+      paramWriter.toArray()
+    );
+    const resultReader = new Utils.Reader(result);
 
     const response: {
-      txid?: TXIDHexString
-      tx?: BEEF
-      noSendChange?: OutpointString[]
+      txid?: TXIDHexString;
+      tx?: BEEF;
+      noSendChange?: OutpointString[];
       sendWithResults?: Array<{
-        txid: TXIDHexString
-        status: 'unproven' | 'sending' | 'failed'
-      }>
+        txid: TXIDHexString;
+        status: "unproven" | "sending" | "failed";
+      }>;
       signableTransaction?: {
-        tx: BEEF
-        reference: Base64String
-      }
-    } = {}
+        tx: BEEF;
+        reference: Base64String;
+      };
+    } = {};
 
     // Parse txid
-    const txidFlag = resultReader.readInt8()
+    const txidFlag = resultReader.readInt8();
     if (txidFlag === 1) {
-      const txidBytes = resultReader.read(32)
-      response.txid = Utils.toHex(txidBytes)
+      const txidBytes = resultReader.read(32);
+      response.txid = Utils.toHex(txidBytes);
     }
 
     // Parse tx
-    const txFlag = resultReader.readInt8()
+    const txFlag = resultReader.readInt8();
     if (txFlag === 1) {
-      const txLength = resultReader.readVarIntNum()
-      response.tx = resultReader.read(txLength)
+      const txLength = resultReader.readVarIntNum();
+      response.tx = resultReader.read(txLength);
     }
 
     // Parse noSendChange
-    const noSendChangeLength = resultReader.readVarIntNum()
+    const noSendChangeLength = resultReader.readVarIntNum();
     if (noSendChangeLength >= 0) {
-      response.noSendChange = []
+      response.noSendChange = [];
       for (let i = 0; i < noSendChangeLength; i++) {
-        const outpoint = this.readOutpoint(resultReader)
-        response.noSendChange.push(outpoint)
+        const outpoint = this.readOutpoint(resultReader);
+        response.noSendChange.push(outpoint);
       }
     }
 
     // Parse sendWithResults
-    const sendWithResultsLength = resultReader.readVarIntNum()
+    const sendWithResultsLength = resultReader.readVarIntNum();
     if (sendWithResultsLength >= 0) {
-      response.sendWithResults = []
+      response.sendWithResults = [];
       for (let i = 0; i < sendWithResultsLength; i++) {
-        const txidBytes = resultReader.read(32)
-        const txid = Utils.toHex(txidBytes)
-        const statusCode = resultReader.readInt8()
-        let status: 'unproven' | 'sending' | 'failed'
-        if (statusCode === 1) status = 'unproven'
-        else if (statusCode === 2) status = 'sending'
-        else if (statusCode === 3) status = 'failed'
-        response.sendWithResults.push({ txid, status })
+        const txidBytes = resultReader.read(32);
+        const txid = Utils.toHex(txidBytes);
+        const statusCode = resultReader.readInt8();
+        let status: "unproven" | "sending" | "failed";
+        if (statusCode === 1) status = "unproven";
+        else if (statusCode === 2) status = "sending";
+        else if (statusCode === 3) status = "failed";
+        response.sendWithResults.push({ txid, status });
       }
     }
 
     // Parse signableTransaction
-    const signableTransactionFlag = resultReader.readInt8()
+    const signableTransactionFlag = resultReader.readInt8();
     if (signableTransactionFlag === 1) {
-      const txLength = resultReader.readVarIntNum()
-      const tx = resultReader.read(txLength)
-      const referenceLength = resultReader.readVarIntNum()
-      const referenceBytes = resultReader.read(referenceLength)
+      const txLength = resultReader.readVarIntNum();
+      const tx = resultReader.read(txLength);
+      const referenceLength = resultReader.readVarIntNum();
+      const referenceBytes = resultReader.read(referenceLength);
       response.signableTransaction = {
         tx,
-        reference: Utils.toBase64(referenceBytes)
-      }
+        reference: Utils.toBase64(referenceBytes),
+      };
     }
 
-    return response
+    return response;
   }
 
-  async signAction(args: SignActionArgs, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<SignActionResult> {
-    const paramWriter = new Utils.Writer()
+  async signAction(
+    args: SignActionArgs,
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<SignActionResult> {
+    const paramWriter = new Utils.Writer();
 
     // Serialize spends
-    const spendIndexes = Object.keys(args.spends)
-    paramWriter.writeVarIntNum(spendIndexes.length)
+    const spendIndexes = Object.keys(args.spends);
+    paramWriter.writeVarIntNum(spendIndexes.length);
     for (const index of spendIndexes) {
-      paramWriter.writeVarIntNum(Number(index))
-      const spend = args.spends[Number(index)]
+      paramWriter.writeVarIntNum(Number(index));
+      const spend = args.spends[Number(index)];
       // unlockingScript
-      const unlockingScriptBytes = Utils.toArray(spend.unlockingScript, 'hex')
-      paramWriter.writeVarIntNum(unlockingScriptBytes.length)
-      paramWriter.write(unlockingScriptBytes)
+      const unlockingScriptBytes = Utils.toArray(spend.unlockingScript, "hex");
+      paramWriter.writeVarIntNum(unlockingScriptBytes.length);
+      paramWriter.write(unlockingScriptBytes);
       // sequenceNumber
-      if (typeof spend.sequenceNumber === 'number') {
-        paramWriter.writeVarIntNum(spend.sequenceNumber)
+      if (typeof spend.sequenceNumber === "number") {
+        paramWriter.writeVarIntNum(spend.sequenceNumber);
       } else {
-        paramWriter.writeVarIntNum(-1)
+        paramWriter.writeVarIntNum(-1);
       }
     }
 
     // Serialize reference
-    const referenceBytes = Utils.toArray(args.reference, 'base64')
-    paramWriter.writeVarIntNum(referenceBytes.length)
-    paramWriter.write(referenceBytes)
+    const referenceBytes = Utils.toArray(args.reference, "base64");
+    paramWriter.writeVarIntNum(referenceBytes.length);
+    paramWriter.write(referenceBytes);
 
     // Serialize options
     if (args.options) {
-      paramWriter.writeInt8(1) // options present
+      paramWriter.writeInt8(1); // options present
 
       // acceptDelayedBroadcast
-      if (typeof args.options.acceptDelayedBroadcast === 'boolean') {
-        paramWriter.writeInt8(args.options.acceptDelayedBroadcast ? 1 : 0)
+      if (typeof args.options.acceptDelayedBroadcast === "boolean") {
+        paramWriter.writeInt8(args.options.acceptDelayedBroadcast ? 1 : 0);
       } else {
-        paramWriter.writeInt8(-1)
+        paramWriter.writeInt8(-1);
       }
 
       // returnTXIDOnly
-      if (typeof args.options.returnTXIDOnly === 'boolean') {
-        paramWriter.writeInt8(args.options.returnTXIDOnly ? 1 : 0)
+      if (typeof args.options.returnTXIDOnly === "boolean") {
+        paramWriter.writeInt8(args.options.returnTXIDOnly ? 1 : 0);
       } else {
-        paramWriter.writeInt8(-1)
+        paramWriter.writeInt8(-1);
       }
 
       // noSend
-      if (typeof args.options.noSend === 'boolean') {
-        paramWriter.writeInt8(args.options.noSend ? 1 : 0)
+      if (typeof args.options.noSend === "boolean") {
+        paramWriter.writeInt8(args.options.noSend ? 1 : 0);
       } else {
-        paramWriter.writeInt8(-1)
+        paramWriter.writeInt8(-1);
       }
 
       // sendWith
       if (args.options.sendWith) {
-        paramWriter.writeVarIntNum(args.options.sendWith.length)
+        paramWriter.writeVarIntNum(args.options.sendWith.length);
         for (const txid of args.options.sendWith) {
-          const txidBytes = Utils.toArray(txid, 'hex')
-          paramWriter.write(txidBytes)
+          const txidBytes = Utils.toArray(txid, "hex");
+          paramWriter.write(txidBytes);
         }
       } else {
-        paramWriter.writeVarIntNum(-1)
+        paramWriter.writeVarIntNum(-1);
       }
     } else {
-      paramWriter.writeInt8(0) // options not present
+      paramWriter.writeInt8(0); // options not present
     }
 
     // Transmit and parse response
-    const result = await this.transmit('signAction', originator, paramWriter.toArray())
-    const resultReader = new Utils.Reader(result)
+    const result = await this.transmit(
+      "signAction",
+      originator,
+      paramWriter.toArray()
+    );
+    const resultReader = new Utils.Reader(result);
 
     const response: {
-      txid?: TXIDHexString
-      tx?: BEEF
-      noSendChange?: OutpointString[]
+      txid?: TXIDHexString;
+      tx?: BEEF;
+      noSendChange?: OutpointString[];
       sendWithResults?: Array<{
-        txid: TXIDHexString
-        status: 'unproven' | 'sending' | 'failed'
-      }>
-    } = {}
+        txid: TXIDHexString;
+        status: "unproven" | "sending" | "failed";
+      }>;
+    } = {};
 
     // Parse txid
-    const txidFlag = resultReader.readInt8()
+    const txidFlag = resultReader.readInt8();
     if (txidFlag === 1) {
-      const txidBytes = resultReader.read(32)
-      response.txid = Utils.toHex(txidBytes)
+      const txidBytes = resultReader.read(32);
+      response.txid = Utils.toHex(txidBytes);
     }
 
     // Parse tx
-    const txFlag = resultReader.readInt8()
+    const txFlag = resultReader.readInt8();
     if (txFlag === 1) {
-      const txLength = resultReader.readVarIntNum()
-      response.tx = resultReader.read(txLength)
+      const txLength = resultReader.readVarIntNum();
+      response.tx = resultReader.read(txLength);
     }
 
     // Parse sendWithResults
-    const sendWithResultsLength = resultReader.readVarIntNum()
+    const sendWithResultsLength = resultReader.readVarIntNum();
     if (sendWithResultsLength >= 0) {
-      response.sendWithResults = []
+      response.sendWithResults = [];
       for (let i = 0; i < sendWithResultsLength; i++) {
-        const txidBytes = resultReader.read(32)
-        const txid = Utils.toHex(txidBytes)
-        const statusCode = resultReader.readInt8()
-        let status: 'unproven' | 'sending' | 'failed'
-        if (statusCode === 1) status = 'unproven'
-        else if (statusCode === 2) status = 'sending'
-        else if (statusCode === 3) status = 'failed'
-        response.sendWithResults.push({ txid, status })
+        const txidBytes = resultReader.read(32);
+        const txid = Utils.toHex(txidBytes);
+        const statusCode = resultReader.readInt8();
+        let status: "unproven" | "sending" | "failed";
+        if (statusCode === 1) status = "unproven";
+        else if (statusCode === 2) status = "sending";
+        else if (statusCode === 3) status = "failed";
+        response.sendWithResults.push({ txid, status });
       }
     }
 
-    return response
+    return response;
   }
 
-  async abortAction(args: { reference: Base64String }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{ aborted: true }> {
-    await this.transmit('abortAction', originator, Utils.toArray(args.reference, 'base64'))
-    return { aborted: true }
+  async abortAction(
+    args: { reference: Base64String },
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<{ aborted: true }> {
+    await this.transmit(
+      "abortAction",
+      originator,
+      Utils.toArray(args.reference, "base64")
+    );
+    return { aborted: true };
   }
 
-  async listActions(args: ListActionsArgs, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<ListActionsResult> {
-    const paramWriter = new Utils.Writer()
+  async listActions(
+    args: ListActionsArgs,
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<ListActionsResult> {
+    const paramWriter = new Utils.Writer();
 
     // Serialize labels
-    paramWriter.writeVarIntNum(args.labels.length)
+    paramWriter.writeVarIntNum(args.labels.length);
     for (const label of args.labels) {
-      const labelBytes = Utils.toArray(label, 'utf8')
-      paramWriter.writeVarIntNum(labelBytes.length)
-      paramWriter.write(labelBytes)
+      const labelBytes = Utils.toArray(label, "utf8");
+      paramWriter.writeVarIntNum(labelBytes.length);
+      paramWriter.write(labelBytes);
     }
 
     // Serialize labelQueryMode
-    if (args.labelQueryMode === 'any') {
-      paramWriter.writeInt8(1)
-    } else if (args.labelQueryMode === 'all') {
-      paramWriter.writeInt8(2)
+    if (args.labelQueryMode === "any") {
+      paramWriter.writeInt8(1);
+    } else if (args.labelQueryMode === "all") {
+      paramWriter.writeInt8(2);
     } else {
-      paramWriter.writeInt8(-1)
+      paramWriter.writeInt8(-1);
     }
 
     // Serialize include options
@@ -473,105 +557,129 @@ export default class WalletWireTransceiver implements WalletInterface {
       args.includeInputSourceLockingScripts,
       args.includeInputUnlockingScripts,
       args.includeOutputs,
-      args.includeOutputLockingScripts
-    ]
+      args.includeOutputLockingScripts,
+    ];
     for (const option of includeOptions) {
-      if (typeof option === 'boolean') {
-        paramWriter.writeInt8(option ? 1 : 0)
+      if (typeof option === "boolean") {
+        paramWriter.writeInt8(option ? 1 : 0);
       } else {
-        paramWriter.writeInt8(-1)
+        paramWriter.writeInt8(-1);
       }
     }
 
     // Serialize limit and offset
-    if (typeof args.limit === 'number') {
-      paramWriter.writeVarIntNum(args.limit)
+    if (typeof args.limit === "number") {
+      paramWriter.writeVarIntNum(args.limit);
     } else {
-      paramWriter.writeVarIntNum(-1)
+      paramWriter.writeVarIntNum(-1);
     }
-    if (typeof args.offset === 'number') {
-      paramWriter.writeVarIntNum(args.offset)
+    if (typeof args.offset === "number") {
+      paramWriter.writeVarIntNum(args.offset);
     } else {
-      paramWriter.writeVarIntNum(-1)
+      paramWriter.writeVarIntNum(-1);
     }
 
     // Serialize seekPermission
-    paramWriter.writeInt8(typeof args.seekPermission === 'boolean' ? args.seekPermission ? 1 : 0 : -1)
+    paramWriter.writeInt8(
+      typeof args.seekPermission === "boolean"
+        ? args.seekPermission
+          ? 1
+          : 0
+        : -1
+    );
 
     // Transmit and parse response
-    const result = await this.transmit('listActions', originator, paramWriter.toArray())
-    const resultReader = new Utils.Reader(result)
-
-    const totalActions = resultReader.readVarIntNum()
+    const result = await this.transmit(
+      "listActions",
+      originator,
+      paramWriter.toArray()
+    );
+    const resultReader = new Utils.Reader(result);
+
+    const totalActions = resultReader.readVarIntNum();
     const actions: Array<{
-      txid: TXIDHexString
-      satoshis: SatoshiValue
-      status: 'completed' | 'unprocessed' | 'sending' | 'unproven' | 'unsigned' | 'nosend' | 'nonfinal'
-      isOutgoing: boolean
-      description: DescriptionString5to50Bytes
-      labels?: LabelStringUnder300Bytes[]
-      version: PositiveIntegerOrZero
-      lockTime: PositiveIntegerOrZero
+      txid: TXIDHexString;
+      satoshis: SatoshiValue;
+      status:
+        | "completed"
+        | "unprocessed"
+        | "sending"
+        | "unproven"
+        | "unsigned"
+        | "nosend"
+        | "nonfinal";
+      isOutgoing: boolean;
+      description: DescriptionString5to50Bytes;
+      labels?: LabelStringUnder300Bytes[];
+      version: PositiveIntegerOrZero;
+      lockTime: PositiveIntegerOrZero;
       inputs?: Array<{
-        sourceOutpoint: OutpointString
-        sourceSatoshis: SatoshiValue
-        sourceLockingScript?: HexString
-        unlockingScript?: HexString
-        inputDescription: DescriptionString5to50Bytes
-        sequenceNumber: PositiveIntegerOrZero
-      }>
+        sourceOutpoint: OutpointString;
+        sourceSatoshis: SatoshiValue;
+        sourceLockingScript?: HexString;
+        unlockingScript?: HexString;
+        inputDescription: DescriptionString5to50Bytes;
+        sequenceNumber: PositiveIntegerOrZero;
+      }>;
       outputs?: Array<{
-        outputIndex: PositiveIntegerOrZero
-        satoshis: SatoshiValue
-        lockingScript?: HexString
-        spendable: boolean
-        outputDescription: DescriptionString5to50Bytes
-        basket: BasketStringUnder300Bytes
-        tags: OutputTagStringUnder300Bytes[]
-        customInstructions?: string
-      }>
-    }> = []
+        outputIndex: PositiveIntegerOrZero;
+        satoshis: SatoshiValue;
+        lockingScript?: HexString;
+        spendable: boolean;
+        outputDescription: DescriptionString5to50Bytes;
+        basket: BasketStringUnder300Bytes;
+        tags: OutputTagStringUnder300Bytes[];
+        customInstructions?: string;
+      }>;
+    }> = [];
 
     for (let i = 0; i < totalActions; i++) {
       // Parse action fields
-      const txidBytes = resultReader.read(32)
-      const txid = Utils.toHex(txidBytes)
-
-      const satoshis = resultReader.readVarIntNum()
-
-      const statusCode = resultReader.readInt8()
-      let status: 'completed' | 'unprocessed' | 'sending' | 'unproven' | 'unsigned' | 'nosend' | 'nonfinal'
+      const txidBytes = resultReader.read(32);
+      const txid = Utils.toHex(txidBytes);
+
+      const satoshis = resultReader.readVarIntNum();
+
+      const statusCode = resultReader.readInt8();
+      let status:
+        | "completed"
+        | "unprocessed"
+        | "sending"
+        | "unproven"
+        | "unsigned"
+        | "nosend"
+        | "nonfinal";
       switch (statusCode) {
         case 1:
-          status = 'completed'
-          break
+          status = "completed";
+          break;
         case 2:
-          status = 'unprocessed'
-          break
+          status = "unprocessed";
+          break;
         case 3:
-          status = 'sending'
-          break
+          status = "sending";
+          break;
         case 4:
-          status = 'unproven'
-          break
+          status = "unproven";
+          break;
         case 5:
-          status = 'unsigned'
-          break
+          status = "unsigned";
+          break;
         case 6:
-          status = 'nosend'
-          break
+          status = "nosend";
+          break;
         case 7:
-          status = 'nonfinal'
-          break
+          status = "nonfinal";
+          break;
         default:
-          throw new Error(`Unknown status code: ${statusCode}`)
+          throw new Error(`Unknown status code: ${statusCode}`);
       }
 
-      const isOutgoing = resultReader.readInt8() === 1
+      const isOutgoing = resultReader.readInt8() === 1;
 
-      const descriptionLength = resultReader.readVarIntNum()
-      const descriptionBytes = resultReader.read(descriptionLength)
-      const description = Utils.toUTF8(descriptionBytes)
+      const descriptionLength = resultReader.readVarIntNum();
+      const descriptionBytes = resultReader.read(descriptionLength);
+      const description = Utils.toUTF8(descriptionBytes);
 
       const action: any = {
         txid,
@@ -580,55 +688,61 @@ export default class WalletWireTransceiver implements WalletInterface {
         isOutgoing,
         description,
         version: 0,
-        lockTime: 0
-      }
+        lockTime: 0,
+      };
 
       // Parse labels
-      const labelsLength = resultReader.readVarIntNum()
+      const labelsLength = resultReader.readVarIntNum();
       if (labelsLength >= 0) {
-        action.labels = []
+        action.labels = [];
         for (let j = 0; j < labelsLength; j++) {
-          const labelLength = resultReader.readVarIntNum()
-          const labelBytes = resultReader.read(labelLength)
-          action.labels.push(Utils.toUTF8(labelBytes))
+          const labelLength = resultReader.readVarIntNum();
+          const labelBytes = resultReader.read(labelLength);
+          action.labels.push(Utils.toUTF8(labelBytes));
         }
       }
 
       // Parse version and lockTime
-      action.version = resultReader.readVarIntNum()
-      action.lockTime = resultReader.readVarIntNum()
+      action.version = resultReader.readVarIntNum();
+      action.lockTime = resultReader.readVarIntNum();
 
       // Parse inputs
-      const inputsLength = resultReader.readVarIntNum()
+      const inputsLength = resultReader.readVarIntNum();
       if (inputsLength >= 0) {
-        action.inputs = []
+        action.inputs = [];
         for (let k = 0; k < inputsLength; k++) {
-          const sourceOutpoint = this.readOutpoint(resultReader)
-          const sourceSatoshis = resultReader.readVarIntNum()
+          const sourceOutpoint = this.readOutpoint(resultReader);
+          const sourceSatoshis = resultReader.readVarIntNum();
 
           // sourceLockingScript
-          const sourceLockingScriptLength = resultReader.readVarIntNum()
-          let sourceLockingScript: string | undefined
+          const sourceLockingScriptLength = resultReader.readVarIntNum();
+          let sourceLockingScript: string | undefined;
           if (sourceLockingScriptLength >= 0) {
-            const sourceLockingScriptBytes = resultReader.read(sourceLockingScriptLength)
-            sourceLockingScript = Utils.toHex(sourceLockingScriptBytes)
+            const sourceLockingScriptBytes = resultReader.read(
+              sourceLockingScriptLength
+            );
+            sourceLockingScript = Utils.toHex(sourceLockingScriptBytes);
           }
 
           // unlockingScript
-          const unlockingScriptLength = resultReader.readVarIntNum()
-          let unlockingScript: string | undefined
+          const unlockingScriptLength = resultReader.readVarIntNum();
+          let unlockingScript: string | undefined;
           if (unlockingScriptLength >= 0) {
-            const unlockingScriptBytes = resultReader.read(unlockingScriptLength)
-            unlockingScript = Utils.toHex(unlockingScriptBytes)
+            const unlockingScriptBytes = resultReader.read(
+              unlockingScriptLength
+            );
+            unlockingScript = Utils.toHex(unlockingScriptBytes);
           }
 
           // inputDescription
-          const inputDescriptionLength = resultReader.readVarIntNum()
-          const inputDescriptionBytes = resultReader.read(inputDescriptionLength)
-          const inputDescription = Utils.toUTF8(inputDescriptionBytes)
+          const inputDescriptionLength = resultReader.readVarIntNum();
+          const inputDescriptionBytes = resultReader.read(
+            inputDescriptionLength
+          );
+          const inputDescription = Utils.toUTF8(inputDescriptionBytes);
 
           // sequenceNumber
-          const sequenceNumber = resultReader.readVarIntNum()
+          const sequenceNumber = resultReader.readVarIntNum();
 
           action.inputs.push({
             sourceOutpoint,
@@ -636,59 +750,63 @@ export default class WalletWireTransceiver implements WalletInterface {
             sourceLockingScript,
             unlockingScript,
             inputDescription,
-            sequenceNumber
-          })
+            sequenceNumber,
+          });
         }
       }
 
       // Parse outputs
-      const outputsLength = resultReader.readVarIntNum()
+      const outputsLength = resultReader.readVarIntNum();
       if (outputsLength >= 0) {
-        action.outputs = []
+        action.outputs = [];
         for (let l = 0; l < outputsLength; l++) {
-          const outputIndex = resultReader.readVarIntNum()
-          const satoshis = resultReader.readVarIntNum()
+          const outputIndex = resultReader.readVarIntNum();
+          const satoshis = resultReader.readVarIntNum();
 
           // lockingScript
-          const lockingScriptLength = resultReader.readVarIntNum()
-          let lockingScript: string | undefined
+          const lockingScriptLength = resultReader.readVarIntNum();
+          let lockingScript: string | undefined;
           if (lockingScriptLength >= 0) {
-            const lockingScriptBytes = resultReader.read(lockingScriptLength)
-            lockingScript = Utils.toHex(lockingScriptBytes)
+            const lockingScriptBytes = resultReader.read(lockingScriptLength);
+            lockingScript = Utils.toHex(lockingScriptBytes);
           }
 
-          const spendable = resultReader.readInt8() === 1
+          const spendable = resultReader.readInt8() === 1;
 
           // outputDescription
-          const outputDescriptionLength = resultReader.readVarIntNum()
-          const outputDescriptionBytes = resultReader.read(outputDescriptionLength)
-          const outputDescription = Utils.toUTF8(outputDescriptionBytes)
+          const outputDescriptionLength = resultReader.readVarIntNum();
+          const outputDescriptionBytes = resultReader.read(
+            outputDescriptionLength
+          );
+          const outputDescription = Utils.toUTF8(outputDescriptionBytes);
 
           // basket
-          const basketLength = resultReader.readVarIntNum()
-          let basket: string | undefined
+          const basketLength = resultReader.readVarIntNum();
+          let basket: string | undefined;
           if (basketLength >= 0) {
-            const basketBytes = resultReader.read(basketLength)
-            basket = Utils.toUTF8(basketBytes)
+            const basketBytes = resultReader.read(basketLength);
+            basket = Utils.toUTF8(basketBytes);
           }
 
           // tags
-          const tagsLength = resultReader.readVarIntNum()
-          const tags: string[] = []
+          const tagsLength = resultReader.readVarIntNum();
+          const tags: string[] = [];
           if (tagsLength >= 0) {
             for (let m = 0; m < tagsLength; m++) {
-              const tagLength = resultReader.readVarIntNum()
-              const tagBytes = resultReader.read(tagLength)
-              tags.push(Utils.toUTF8(tagBytes))
+              const tagLength = resultReader.readVarIntNum();
+              const tagBytes = resultReader.read(tagLength);
+              tags.push(Utils.toUTF8(tagBytes));
             }
           }
 
           // customInstructions
-          const customInstructionsLength = resultReader.readVarIntNum()
-          let customInstructions: string | undefined
+          const customInstructionsLength = resultReader.readVarIntNum();
+          let customInstructions: string | undefined;
           if (customInstructionsLength >= 0) {
-            const customInstructionsBytes = resultReader.read(customInstructionsLength)
-            customInstructions = Utils.toUTF8(customInstructionsBytes)
+            const customInstructionsBytes = resultReader.read(
+              customInstructionsLength
+            );
+            customInstructions = Utils.toUTF8(customInstructionsBytes);
           }
 
           action.outputs.push({
@@ -699,283 +817,432 @@ export default class WalletWireTransceiver implements WalletInterface {
             outputDescription,
             basket,
             tags,
-            customInstructions
-          })
+            customInstructions,
+          });
         }
       }
 
-      actions.push(action)
+      actions.push(action);
     }
 
     return {
       totalActions,
-      actions
-    }
+      actions,
+    };
   }
 
-  async internalizeAction(args: InternalizeActionArgs, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{ accepted: true }> {
-    const paramWriter = new Utils.Writer()
-    paramWriter.writeVarIntNum(args.tx.length)
-    paramWriter.write(args.tx)
-    paramWriter.writeVarIntNum(args.outputs.length)
+  async internalizeAction(
+    args: InternalizeActionArgs,
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<{ accepted: true }> {
+    const paramWriter = new Utils.Writer();
+    paramWriter.writeVarIntNum(args.tx.length);
+    paramWriter.write(args.tx);
+    paramWriter.writeVarIntNum(args.outputs.length);
     for (const out of args.outputs) {
-      paramWriter.writeVarIntNum(out.outputIndex)
-      if (out.protocol === 'wallet payment') {
-        paramWriter.writeUInt8(1)
-        paramWriter.write(Utils.toArray(out.paymentRemittance.senderIdentityKey, 'hex'))
-        const derivationPrefixAsArray = Utils.toArray(out.paymentRemittance.derivationPrefix, 'base64')
-        paramWriter.writeVarIntNum(derivationPrefixAsArray.length)
-        paramWriter.write(derivationPrefixAsArray)
-        const derivationSuffixAsArray = Utils.toArray(out.paymentRemittance.derivationSuffix, 'base64')
-        paramWriter.writeVarIntNum(derivationSuffixAsArray.length)
-        paramWriter.write(derivationSuffixAsArray)
+      paramWriter.writeVarIntNum(out.outputIndex);
+      if (out.protocol === "wallet payment") {
+        paramWriter.writeUInt8(1);
+        paramWriter.write(
+          Utils.toArray(out.paymentRemittance.senderIdentityKey, "hex")
+        );
+        const derivationPrefixAsArray = Utils.toArray(
+          out.paymentRemittance.derivationPrefix,
+          "base64"
+        );
+        paramWriter.writeVarIntNum(derivationPrefixAsArray.length);
+        paramWriter.write(derivationPrefixAsArray);
+        const derivationSuffixAsArray = Utils.toArray(
+          out.paymentRemittance.derivationSuffix,
+          "base64"
+        );
+        paramWriter.writeVarIntNum(derivationSuffixAsArray.length);
+        paramWriter.write(derivationSuffixAsArray);
       } else {
-        paramWriter.writeUInt8(2)
-        const basketAsArray = Utils.toArray(out.insertionRemittance.basket, 'utf8')
-        paramWriter.writeVarIntNum(basketAsArray.length)
-        paramWriter.write(basketAsArray)
+        paramWriter.writeUInt8(2);
+        const basketAsArray = Utils.toArray(
+          out.insertionRemittance.basket,
+          "utf8"
+        );
+        paramWriter.writeVarIntNum(basketAsArray.length);
+        paramWriter.write(basketAsArray);
         if (typeof out.insertionRemittance.customInstructions) {
-          const customInstructionsAsArray = Utils.toArray(out.insertionRemittance.customInstructions, 'utf8')
-          paramWriter.writeVarIntNum(customInstructionsAsArray.length)
-          paramWriter.write(customInstructionsAsArray)
+          const customInstructionsAsArray = Utils.toArray(
+            out.insertionRemittance.customInstructions,
+            "utf8"
+          );
+          paramWriter.writeVarIntNum(customInstructionsAsArray.length);
+          paramWriter.write(customInstructionsAsArray);
         } else {
-          paramWriter.writeVarIntNum(-1)
+          paramWriter.writeVarIntNum(-1);
         }
-        if (typeof out.insertionRemittance.tags === 'object') {
-          paramWriter.writeVarIntNum(out.insertionRemittance.tags.length)
+        if (typeof out.insertionRemittance.tags === "object") {
+          paramWriter.writeVarIntNum(out.insertionRemittance.tags.length);
           for (const tag of out.insertionRemittance.tags) {
-            const tagAsArray = Utils.toArray(tag, 'utf8')
-            paramWriter.writeVarIntNum(tagAsArray.length)
-            paramWriter.write(tagAsArray)
+            const tagAsArray = Utils.toArray(tag, "utf8");
+            paramWriter.writeVarIntNum(tagAsArray.length);
+            paramWriter.write(tagAsArray);
           }
         } else {
-          paramWriter.writeVarIntNum(0)
+          paramWriter.writeVarIntNum(0);
         }
       }
     }
-    if (typeof args.labels === 'object') {
-      paramWriter.writeVarIntNum(args.labels.length)
+    if (typeof args.labels === "object") {
+      paramWriter.writeVarIntNum(args.labels.length);
       for (const l of args.labels) {
-        const labelAsArray = Utils.toArray(l, 'utf8')
-        paramWriter.writeVarIntNum(labelAsArray.length)
-        paramWriter.write(labelAsArray)
+        const labelAsArray = Utils.toArray(l, "utf8");
+        paramWriter.writeVarIntNum(labelAsArray.length);
+        paramWriter.write(labelAsArray);
       }
     } else {
-      paramWriter.writeVarIntNum(-1)
+      paramWriter.writeVarIntNum(-1);
     }
-    const descriptionAsArray = Utils.toArray(args.description)
-    paramWriter.writeVarIntNum(descriptionAsArray.length)
-    paramWriter.write(descriptionAsArray)
+    const descriptionAsArray = Utils.toArray(args.description);
+    paramWriter.writeVarIntNum(descriptionAsArray.length);
+    paramWriter.write(descriptionAsArray);
 
     // Serialize seekPermission
-    paramWriter.writeInt8(typeof args.seekPermission === 'boolean' ? args.seekPermission ? 1 : 0 : -1)
-
-    await this.transmit('internalizeAction', originator, paramWriter.toArray())
-    return { accepted: true }
+    paramWriter.writeInt8(
+      typeof args.seekPermission === "boolean"
+        ? args.seekPermission
+          ? 1
+          : 0
+        : -1
+    );
+
+    await this.transmit("internalizeAction", originator, paramWriter.toArray());
+    return { accepted: true };
   }
 
-  async listOutputs(args: ListOutputsArgs, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<ListOutputsResult> {
-    const paramWriter = new Utils.Writer()
-    const basketAsArray = Utils.toArray(args.basket, 'utf8')
-    paramWriter.writeVarIntNum(basketAsArray.length)
-    paramWriter.write(basketAsArray)
-    if (typeof args.tags === 'object') {
-      paramWriter.writeVarIntNum(args.tags.length)
+  async listOutputs(
+    args: ListOutputsArgs,
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<ListOutputsResult> {
+    const paramWriter = new Utils.Writer();
+    const basketAsArray = Utils.toArray(args.basket, "utf8");
+    paramWriter.writeVarIntNum(basketAsArray.length);
+    paramWriter.write(basketAsArray);
+    if (typeof args.tags === "object") {
+      paramWriter.writeVarIntNum(args.tags.length);
       for (const tag of args.tags) {
-        const tagAsArray = Utils.toArray(tag, 'utf8')
-        paramWriter.writeVarIntNum(tagAsArray.length)
-        paramWriter.write(tagAsArray)
+        const tagAsArray = Utils.toArray(tag, "utf8");
+        paramWriter.writeVarIntNum(tagAsArray.length);
+        paramWriter.write(tagAsArray);
       }
     } else {
-      paramWriter.writeVarIntNum(0)
+      paramWriter.writeVarIntNum(0);
     }
-    if (args.tagQueryMode === 'all') {
-      paramWriter.writeInt8(1)
-    } else if (args.tagQueryMode === 'any') {
-      paramWriter.writeInt8(2)
+    if (args.tagQueryMode === "all") {
+      paramWriter.writeInt8(1);
+    } else if (args.tagQueryMode === "any") {
+      paramWriter.writeInt8(2);
     } else {
-      paramWriter.writeInt8(-1)
+      paramWriter.writeInt8(-1);
     }
-    if (args.include === 'locking scripts') {
-      paramWriter.writeInt8(1)
-    } else if (args.include === 'entire transactions') {
-      paramWriter.writeInt8(2)
+    if (args.include === "locking scripts") {
+      paramWriter.writeInt8(1);
+    } else if (args.include === "entire transactions") {
+      paramWriter.writeInt8(2);
     } else {
-      paramWriter.writeInt8(-1)
+      paramWriter.writeInt8(-1);
     }
-    if (typeof args.includeCustomInstructions === 'boolean') {
-      paramWriter.writeInt8(args.includeCustomInstructions ? 1 : 0)
+    if (typeof args.includeCustomInstructions === "boolean") {
+      paramWriter.writeInt8(args.includeCustomInstructions ? 1 : 0);
     } else {
-      paramWriter.writeInt8(-1)
+      paramWriter.writeInt8(-1);
     }
-    if (typeof args.includeTags === 'boolean') {
-      paramWriter.writeInt8(args.includeTags ? 1 : 0)
+    if (typeof args.includeTags === "boolean") {
+      paramWriter.writeInt8(args.includeTags ? 1 : 0);
     } else {
-      paramWriter.writeInt8(-1)
+      paramWriter.writeInt8(-1);
     }
-    if (typeof args.includeLabels === 'boolean') {
-      paramWriter.writeInt8(args.includeLabels ? 1 : 0)
+    if (typeof args.includeLabels === "boolean") {
+      paramWriter.writeInt8(args.includeLabels ? 1 : 0);
     } else {
-      paramWriter.writeInt8(-1)
+      paramWriter.writeInt8(-1);
     }
-    if (typeof args.limit === 'number') {
-      paramWriter.writeVarIntNum(args.limit)
+    if (typeof args.limit === "number") {
+      paramWriter.writeVarIntNum(args.limit);
     } else {
-      paramWriter.writeVarIntNum(-1)
+      paramWriter.writeVarIntNum(-1);
     }
-    if (typeof args.offset === 'number') {
-      paramWriter.writeVarIntNum(args.offset)
+    if (typeof args.offset === "number") {
+      paramWriter.writeVarIntNum(args.offset);
     } else {
-      paramWriter.writeVarIntNum(-1)
+      paramWriter.writeVarIntNum(-1);
     }
 
     // Serialize seekPermission
-    paramWriter.writeInt8(typeof args.seekPermission === 'boolean' ? args.seekPermission ? 1 : 0 : -1)
-
-    const result = await this.transmit('listOutputs', originator, paramWriter.toArray())
-    const resultReader = new Utils.Reader(result)
-    const totalOutputs = resultReader.readVarIntNum()
-    const beefLength = resultReader.readVarIntNum()
-    let BEEF = undefined
+    paramWriter.writeInt8(
+      typeof args.seekPermission === "boolean"
+        ? args.seekPermission
+          ? 1
+          : 0
+        : -1
+    );
+
+    const result = await this.transmit(
+      "listOutputs",
+      originator,
+      paramWriter.toArray()
+    );
+    const resultReader = new Utils.Reader(result);
+    const totalOutputs = resultReader.readVarIntNum();
+    const beefLength = resultReader.readVarIntNum();
+    let BEEF = undefined;
     if (beefLength >= 0) {
-      BEEF = resultReader.read(beefLength)
-    }
-    const outputs: Array<{ outpoint: OutpointString, satoshis: SatoshiValue, lockingScript?: HexString, tx?: BEEF, spendable: true, customInstructions?: string, tags?: OutputTagStringUnder300Bytes[], labels?: LabelStringUnder300Bytes[] }> = []
+      BEEF = resultReader.read(beefLength);
+    }
+    const outputs: Array<{
+      outpoint: OutpointString;
+      satoshis: SatoshiValue;
+      lockingScript?: HexString;
+      tx?: BEEF;
+      spendable: true;
+      customInstructions?: string;
+      tags?: OutputTagStringUnder300Bytes[];
+      labels?: LabelStringUnder300Bytes[];
+    }> = [];
     for (let i = 0; i < totalOutputs; i++) {
-      const outpoint = this.readOutpoint(resultReader)
-      const satoshis = resultReader.readVarIntNum()
-      const output: { outpoint: OutpointString, satoshis: SatoshiValue, lockingScript?: HexString, tx?: BEEF, spendable: true, customInstructions?: string, tags?: OutputTagStringUnder300Bytes[], labels?: LabelStringUnder300Bytes[] } = {
+      const outpoint = this.readOutpoint(resultReader);
+      const satoshis = resultReader.readVarIntNum();
+      const output: {
+        outpoint: OutpointString;
+        satoshis: SatoshiValue;
+        lockingScript?: HexString;
+        tx?: BEEF;
+        spendable: true;
+        customInstructions?: string;
+        tags?: OutputTagStringUnder300Bytes[];
+        labels?: LabelStringUnder300Bytes[];
+      } = {
         spendable: true,
         outpoint,
-        satoshis
-      }
-      const scriptLength = resultReader.readVarIntNum()
+        satoshis,
+      };
+      const scriptLength = resultReader.readVarIntNum();
       if (scriptLength >= 0) {
-        output.lockingScript = Utils.toHex(resultReader.read(scriptLength))
+        output.lockingScript = Utils.toHex(resultReader.read(scriptLength));
       }
-      const customInstructionsLength = resultReader.readVarIntNum()
+      const customInstructionsLength = resultReader.readVarIntNum();
       if (customInstructionsLength >= 0) {
-        output.customInstructions = Utils.toUTF8(resultReader.read(customInstructionsLength))
+        output.customInstructions = Utils.toUTF8(
+          resultReader.read(customInstructionsLength)
+        );
       }
-      const tagsLength = resultReader.readVarIntNum()
+      const tagsLength = resultReader.readVarIntNum();
       if (tagsLength !== -1) {
-        const tags: OutputTagStringUnder300Bytes[] = []
+        const tags: OutputTagStringUnder300Bytes[] = [];
         for (let i = 0; i < tagsLength; i++) {
-          const tagLength = resultReader.readVarIntNum()
-          tags.push(Utils.toUTF8(resultReader.read(tagLength)))
+          const tagLength = resultReader.readVarIntNum();
+          tags.push(Utils.toUTF8(resultReader.read(tagLength)));
         }
-        output.tags = tags
+        output.tags = tags;
       }
-      const labelsLength = resultReader.readVarIntNum()
+      const labelsLength = resultReader.readVarIntNum();
       if (labelsLength !== -1) {
-        const labels: LabelStringUnder300Bytes[] = []
+        const labels: LabelStringUnder300Bytes[] = [];
         for (let i = 0; i < labelsLength; i++) {
-          const labelLength = resultReader.readVarIntNum()
-          labels.push(Utils.toUTF8(resultReader.read(labelLength)))
+          const labelLength = resultReader.readVarIntNum();
+          labels.push(Utils.toUTF8(resultReader.read(labelLength)));
         }
-        output.labels = labels
+        output.labels = labels;
       }
-      outputs.push(output)
+      outputs.push(output);
     }
     return {
       totalOutputs,
       BEEF,
-      outputs
-    }
+      outputs,
+    };
   }
 
-  async relinquishOutput(args: { basket: BasketStringUnder300Bytes, output: OutpointString }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{ relinquished: true }> {
-    const paramWriter = new Utils.Writer()
-    const basketAsArray = Utils.toArray(args.basket, 'utf8')
-    paramWriter.writeVarIntNum(basketAsArray.length)
-    paramWriter.write(basketAsArray)
-    paramWriter.write(this.encodeOutpoint(args.output))
-    await this.transmit('relinquishOutput', originator, paramWriter.toArray())
-    return { relinquished: true }
+  async relinquishOutput(
+    args: { basket: BasketStringUnder300Bytes; output: OutpointString },
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<{ relinquished: true }> {
+    const paramWriter = new Utils.Writer();
+    const basketAsArray = Utils.toArray(args.basket, "utf8");
+    paramWriter.writeVarIntNum(basketAsArray.length);
+    paramWriter.write(basketAsArray);
+    paramWriter.write(this.encodeOutpoint(args.output));
+    await this.transmit("relinquishOutput", originator, paramWriter.toArray());
+    return { relinquished: true };
   }
 
   private encodeOutpoint(outpoint: OutpointString): 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();
   }
 
   private readOutpoint(reader: Utils.Reader): OutpointString {
-    const txid = Utils.toHex(reader.read(32))
-    const index = reader.readVarIntNum()
-    return `${txid}.${index}`
+    const txid = Utils.toHex(reader.read(32));
+    const index = reader.readVarIntNum();
+    return `${txid}.${index}`;
   }
 
-  async getPublicKey(args: { seekPermission?: BooleanDefaultTrue, identityKey?: true, protocolID?: [SecurityLevel, ProtocolString5To400Bytes], keyID?: KeyIDStringUnder800Bytes, privileged?: BooleanDefaultFalse, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', forSelf?: BooleanDefaultFalse }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{ publicKey: PubKeyHex }> {
-    const paramWriter = new Utils.Writer()
-    paramWriter.writeUInt8(args.identityKey ? 1 : 0)
+  async getPublicKey(
+    args: {
+      seekPermission?: BooleanDefaultTrue;
+      identityKey?: true;
+      protocolID?: [SecurityLevel, ProtocolString5To400Bytes];
+      keyID?: KeyIDStringUnder800Bytes;
+      privileged?: BooleanDefaultFalse;
+      privilegedReason?: DescriptionString5to50Bytes;
+      counterparty?: PubKeyHex | "self" | "anyone";
+      forSelf?: BooleanDefaultFalse;
+    },
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<{ publicKey: PubKeyHex }> {
+    const paramWriter = new Utils.Writer();
+    paramWriter.writeUInt8(args.identityKey ? 1 : 0);
     if (!args.identityKey) {
-      paramWriter.write(this.encodeKeyRelatedParams(args.protocolID, args.keyID, args.counterparty, args.privileged, args.privilegedReason))
-      if (typeof args.forSelf === 'boolean') {
-        paramWriter.writeInt8(args.forSelf ? 1 : 0)
+      paramWriter.write(
+        this.encodeKeyRelatedParams(
+          args.protocolID,
+          args.keyID,
+          args.counterparty,
+          args.privileged,
+          args.privilegedReason
+        )
+      );
+      if (typeof args.forSelf === "boolean") {
+        paramWriter.writeInt8(args.forSelf ? 1 : 0);
       } else {
-        paramWriter.writeInt8(-1)
+        paramWriter.writeInt8(-1);
       }
     } else {
-      paramWriter.write(this.encodePrivilegedParams(args.privileged, args.privilegedReason))
+      paramWriter.write(
+        this.encodePrivilegedParams(args.privileged, args.privilegedReason)
+      );
     }
 
     // Serialize seekPermission
-    paramWriter.writeInt8(typeof args.seekPermission === 'boolean' ? args.seekPermission ? 1 : 0 : -1)
-
-    const result = await this.transmit('getPublicKey', originator, paramWriter.toArray())
+    paramWriter.writeInt8(
+      typeof args.seekPermission === "boolean"
+        ? args.seekPermission
+          ? 1
+          : 0
+        : -1
+    );
+
+    const result = await this.transmit(
+      "getPublicKey",
+      originator,
+      paramWriter.toArray()
+    );
     return {
-      publicKey: Utils.toHex(result)
-    }
+      publicKey: Utils.toHex(result),
+    };
   }
 
-  async revealCounterpartyKeyLinkage(args: { counterparty: PubKeyHex, verifier: PubKeyHex, privilegedReason?: DescriptionString5to50Bytes, privileged?: BooleanDefaultFalse }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{ prover: PubKeyHex, verifier: PubKeyHex, counterparty: PubKeyHex, revelationTime: ISOTimestampString, encryptedLinkage: Byte[], encryptedLinkageProof: number[] }> {
-    const paramWriter = new Utils.Writer()
-    paramWriter.write(this.encodePrivilegedParams(args.privileged, args.privilegedReason))
-    paramWriter.write(Utils.toArray(args.counterparty, 'hex'))
-    paramWriter.write(Utils.toArray(args.verifier, 'hex'))
-    const result = await this.transmit('revealCounterpartyKeyLinkage', originator, paramWriter.toArray())
-    const resultReader = new Utils.Reader(result)
-    const prover = Utils.toHex(resultReader.read(33))
-    const verifier = Utils.toHex(resultReader.read(33))
-    const counterparty = Utils.toHex(resultReader.read(33))
-    const revelationTimeLength = resultReader.readVarIntNum()
-    const revelationTime = Utils.toUTF8(resultReader.read(revelationTimeLength))
-    const encryptedLinkageLength = resultReader.readVarIntNum()
-    const encryptedLinkage = resultReader.read(encryptedLinkageLength)
-    const encryptedLinkageProofLength = resultReader.readVarIntNum()
-    const encryptedLinkageProof = resultReader.read(encryptedLinkageProofLength)
+  async revealCounterpartyKeyLinkage(
+    args: {
+      counterparty: PubKeyHex;
+      verifier: PubKeyHex;
+      privilegedReason?: DescriptionString5to50Bytes;
+      privileged?: BooleanDefaultFalse;
+    },
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<{
+    prover: PubKeyHex;
+    verifier: PubKeyHex;
+    counterparty: PubKeyHex;
+    revelationTime: ISOTimestampString;
+    encryptedLinkage: Byte[];
+    encryptedLinkageProof: number[];
+  }> {
+    const paramWriter = new Utils.Writer();
+    paramWriter.write(
+      this.encodePrivilegedParams(args.privileged, args.privilegedReason)
+    );
+    paramWriter.write(Utils.toArray(args.counterparty, "hex"));
+    paramWriter.write(Utils.toArray(args.verifier, "hex"));
+    const result = await this.transmit(
+      "revealCounterpartyKeyLinkage",
+      originator,
+      paramWriter.toArray()
+    );
+    const resultReader = new Utils.Reader(result);
+    const prover = Utils.toHex(resultReader.read(33));
+    const verifier = Utils.toHex(resultReader.read(33));
+    const counterparty = Utils.toHex(resultReader.read(33));
+    const revelationTimeLength = resultReader.readVarIntNum();
+    const revelationTime = Utils.toUTF8(
+      resultReader.read(revelationTimeLength)
+    );
+    const encryptedLinkageLength = resultReader.readVarIntNum();
+    const encryptedLinkage = resultReader.read(encryptedLinkageLength);
+    const encryptedLinkageProofLength = resultReader.readVarIntNum();
+    const encryptedLinkageProof = resultReader.read(
+      encryptedLinkageProofLength
+    );
     return {
       prover,
       verifier,
       counterparty,
       revelationTime,
       encryptedLinkage,
-      encryptedLinkageProof
-    }
+      encryptedLinkageProof,
+    };
   }
 
-  async revealSpecificKeyLinkage(args: { counterparty: PubKeyHex, verifier: PubKeyHex, protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, privileged?: BooleanDefaultFalse }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{ prover: PubKeyHex, verifier: PubKeyHex, counterparty: PubKeyHex, protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, encryptedLinkage: Byte[], encryptedLinkageProof: Byte[], proofType: Byte }> {
-    const paramWriter = new Utils.Writer()
-    paramWriter.write(this.encodeKeyRelatedParams(args.protocolID, args.keyID, args.counterparty, args.privileged, args.privilegedReason))
-    paramWriter.write(Utils.toArray(args.verifier, 'hex'))
-    const result = await this.transmit('revealSpecificKeyLinkage', originator, paramWriter.toArray())
-    const resultReader = new Utils.Reader(result)
-    const prover = Utils.toHex(resultReader.read(33))
-    const verifier = Utils.toHex(resultReader.read(33))
-    const counterparty = Utils.toHex(resultReader.read(33))
-    const securityLevel = resultReader.readUInt8()
-    const protocolLength = resultReader.readVarIntNum()
-    const protocol = Utils.toUTF8(resultReader.read(protocolLength))
-    const keyIDLength = resultReader.readVarIntNum()
-    const keyID = Utils.toUTF8(resultReader.read(keyIDLength))
-    const encryptedLinkageLength = resultReader.readVarIntNum()
-    const encryptedLinkage = resultReader.read(encryptedLinkageLength)
-    const encryptedLinkageProofLength = resultReader.readVarIntNum()
-    const encryptedLinkageProof = resultReader.read(encryptedLinkageProofLength)
-    const proofType = resultReader.readUInt8()
+  async revealSpecificKeyLinkage(
+    args: {
+      counterparty: PubKeyHex;
+      verifier: PubKeyHex;
+      protocolID: [SecurityLevel, ProtocolString5To400Bytes];
+      keyID: KeyIDStringUnder800Bytes;
+      privilegedReason?: DescriptionString5to50Bytes;
+      privileged?: BooleanDefaultFalse;
+    },
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<{
+    prover: PubKeyHex;
+    verifier: PubKeyHex;
+    counterparty: PubKeyHex;
+    protocolID: [SecurityLevel, ProtocolString5To400Bytes];
+    keyID: KeyIDStringUnder800Bytes;
+    encryptedLinkage: Byte[];
+    encryptedLinkageProof: Byte[];
+    proofType: Byte;
+  }> {
+    const paramWriter = new Utils.Writer();
+    paramWriter.write(
+      this.encodeKeyRelatedParams(
+        args.protocolID,
+        args.keyID,
+        args.counterparty,
+        args.privileged,
+        args.privilegedReason
+      )
+    );
+    paramWriter.write(Utils.toArray(args.verifier, "hex"));
+    const result = await this.transmit(
+      "revealSpecificKeyLinkage",
+      originator,
+      paramWriter.toArray()
+    );
+    const resultReader = new Utils.Reader(result);
+    const prover = Utils.toHex(resultReader.read(33));
+    const verifier = Utils.toHex(resultReader.read(33));
+    const counterparty = Utils.toHex(resultReader.read(33));
+    const securityLevel = resultReader.readUInt8();
+    const protocolLength = resultReader.readVarIntNum();
+    const protocol = Utils.toUTF8(resultReader.read(protocolLength));
+    const keyIDLength = resultReader.readVarIntNum();
+    const keyID = Utils.toUTF8(resultReader.read(keyIDLength));
+    const encryptedLinkageLength = resultReader.readVarIntNum();
+    const encryptedLinkage = resultReader.read(encryptedLinkageLength);
+    const encryptedLinkageProofLength = resultReader.readVarIntNum();
+    const encryptedLinkageProof = resultReader.read(
+      encryptedLinkageProofLength
+    );
+    const proofType = resultReader.readUInt8();
     return {
       prover,
       verifier,
@@ -984,472 +1251,775 @@ export default class WalletWireTransceiver implements WalletInterface {
       keyID,
       encryptedLinkage,
       encryptedLinkageProof,
-      proofType
-    }
+      proofType,
+    };
   }
 
-  async encrypt(args: { seekPermission?: BooleanDefaultTrue, plaintext: Byte[], protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{ ciphertext: Byte[] }> {
-    const paramWriter = new Utils.Writer()
-    paramWriter.write(this.encodeKeyRelatedParams(args.protocolID, args.keyID, args.counterparty, args.privileged, args.privilegedReason))
-    paramWriter.writeVarIntNum(args.plaintext.length)
-    paramWriter.write(args.plaintext)
+  async encrypt(
+    args: {
+      seekPermission?: BooleanDefaultTrue;
+      plaintext: Byte[];
+      protocolID: [SecurityLevel, ProtocolString5To400Bytes];
+      keyID: KeyIDStringUnder800Bytes;
+      privilegedReason?: DescriptionString5to50Bytes;
+      counterparty?: PubKeyHex | "self" | "anyone";
+      privileged?: BooleanDefaultFalse;
+    },
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<{ ciphertext: Byte[] }> {
+    const paramWriter = new Utils.Writer();
+    paramWriter.write(
+      this.encodeKeyRelatedParams(
+        args.protocolID,
+        args.keyID,
+        args.counterparty,
+        args.privileged,
+        args.privilegedReason
+      )
+    );
+    paramWriter.writeVarIntNum(args.plaintext.length);
+    paramWriter.write(args.plaintext);
     // Serialize seekPermission
-    paramWriter.writeInt8(typeof args.seekPermission === 'boolean' ? args.seekPermission ? 1 : 0 : -1)
+    paramWriter.writeInt8(
+      typeof args.seekPermission === "boolean"
+        ? args.seekPermission
+          ? 1
+          : 0
+        : -1
+    );
     return {
-      ciphertext: await this.transmit('encrypt', originator, paramWriter.toArray())
-    }
+      ciphertext: await this.transmit(
+        "encrypt",
+        originator,
+        paramWriter.toArray()
+      ),
+    };
   }
 
-  async decrypt(args: { seekPermission?: BooleanDefaultTrue, ciphertext: Byte[], protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{ plaintext: Byte[] }> {
-    const paramWriter = new Utils.Writer()
-    paramWriter.write(this.encodeKeyRelatedParams(args.protocolID, args.keyID, args.counterparty, args.privileged, args.privilegedReason))
-    paramWriter.writeVarIntNum(args.ciphertext.length)
-    paramWriter.write(args.ciphertext)
+  async decrypt(
+    args: {
+      seekPermission?: BooleanDefaultTrue;
+      ciphertext: Byte[];
+      protocolID: [SecurityLevel, ProtocolString5To400Bytes];
+      keyID: KeyIDStringUnder800Bytes;
+      privilegedReason?: DescriptionString5to50Bytes;
+      counterparty?: PubKeyHex | "self" | "anyone";
+      privileged?: BooleanDefaultFalse;
+    },
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<{ plaintext: Byte[] }> {
+    const paramWriter = new Utils.Writer();
+    paramWriter.write(
+      this.encodeKeyRelatedParams(
+        args.protocolID,
+        args.keyID,
+        args.counterparty,
+        args.privileged,
+        args.privilegedReason
+      )
+    );
+    paramWriter.writeVarIntNum(args.ciphertext.length);
+    paramWriter.write(args.ciphertext);
     // Serialize seekPermission
-    paramWriter.writeInt8(typeof args.seekPermission === 'boolean' ? args.seekPermission ? 1 : 0 : -1)
+    paramWriter.writeInt8(
+      typeof args.seekPermission === "boolean"
+        ? args.seekPermission
+          ? 1
+          : 0
+        : -1
+    );
     return {
-      plaintext: await this.transmit('decrypt', originator, paramWriter.toArray())
-    }
+      plaintext: await this.transmit(
+        "decrypt",
+        originator,
+        paramWriter.toArray()
+      ),
+    };
   }
 
-  async createHmac(args: { seekPermission?: BooleanDefaultTrue, data: Byte[], protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{ hmac: Byte[] }> {
-    const paramWriter = new Utils.Writer()
-    paramWriter.write(this.encodeKeyRelatedParams(args.protocolID, args.keyID, args.counterparty, args.privileged, args.privilegedReason))
-    paramWriter.writeVarIntNum(args.data.length)
-    paramWriter.write(args.data)
+  async createHmac(
+    args: {
+      seekPermission?: BooleanDefaultTrue;
+      data: Byte[];
+      protocolID: [SecurityLevel, ProtocolString5To400Bytes];
+      keyID: KeyIDStringUnder800Bytes;
+      privilegedReason?: DescriptionString5to50Bytes;
+      counterparty?: PubKeyHex | "self" | "anyone";
+      privileged?: BooleanDefaultFalse;
+    },
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<{ hmac: Byte[] }> {
+    const paramWriter = new Utils.Writer();
+    paramWriter.write(
+      this.encodeKeyRelatedParams(
+        args.protocolID,
+        args.keyID,
+        args.counterparty,
+        args.privileged,
+        args.privilegedReason
+      )
+    );
+    paramWriter.writeVarIntNum(args.data.length);
+    paramWriter.write(args.data);
     // Serialize seekPermission
-    paramWriter.writeInt8(typeof args.seekPermission === 'boolean' ? args.seekPermission ? 1 : 0 : -1)
+    paramWriter.writeInt8(
+      typeof args.seekPermission === "boolean"
+        ? args.seekPermission
+          ? 1
+          : 0
+        : -1
+    );
     return {
-      hmac: await this.transmit('createHmac', originator, paramWriter.toArray())
-    }
+      hmac: await this.transmit(
+        "createHmac",
+        originator,
+        paramWriter.toArray()
+      ),
+    };
   }
 
-  async verifyHmac(args: { seekPermission?: BooleanDefaultTrue, data: Byte[], hmac: Byte[], protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{ valid: true }> {
-    const paramWriter = new Utils.Writer()
-    paramWriter.write(this.encodeKeyRelatedParams(args.protocolID, args.keyID, args.counterparty, args.privileged, args.privilegedReason))
-    paramWriter.write(args.hmac)
-    paramWriter.writeVarIntNum(args.data.length)
-    paramWriter.write(args.data)
+  async verifyHmac(
+    args: {
+      seekPermission?: BooleanDefaultTrue;
+      data: Byte[];
+      hmac: Byte[];
+      protocolID: [SecurityLevel, ProtocolString5To400Bytes];
+      keyID: KeyIDStringUnder800Bytes;
+      privilegedReason?: DescriptionString5to50Bytes;
+      counterparty?: PubKeyHex | "self" | "anyone";
+      privileged?: BooleanDefaultFalse;
+    },
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<{ valid: true }> {
+    const paramWriter = new Utils.Writer();
+    paramWriter.write(
+      this.encodeKeyRelatedParams(
+        args.protocolID,
+        args.keyID,
+        args.counterparty,
+        args.privileged,
+        args.privilegedReason
+      )
+    );
+    paramWriter.write(args.hmac);
+    paramWriter.writeVarIntNum(args.data.length);
+    paramWriter.write(args.data);
     // Serialize seekPermission
-    paramWriter.writeInt8(typeof args.seekPermission === 'boolean' ? args.seekPermission ? 1 : 0 : -1)
-    await this.transmit('verifyHmac', originator, paramWriter.toArray())
-    return { valid: true }
+    paramWriter.writeInt8(
+      typeof args.seekPermission === "boolean"
+        ? args.seekPermission
+          ? 1
+          : 0
+        : -1
+    );
+    await this.transmit("verifyHmac", originator, paramWriter.toArray());
+    return { valid: true };
   }
 
-  async createSignature(args: { seekPermission?: BooleanDefaultTrue, data?: Byte[], hashToDirectlySign?: Byte[], protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{ signature: Byte[] }> {
-    const paramWriter = new Utils.Writer()
-    paramWriter.write(this.encodeKeyRelatedParams(args.protocolID, args.keyID, args.counterparty, args.privileged, args.privilegedReason))
-    if (typeof args.data === 'object') {
-      paramWriter.writeUInt8(1)
-      paramWriter.writeVarIntNum(args.data.length)
-      paramWriter.write(args.data)
+  async createSignature(
+    args: {
+      seekPermission?: BooleanDefaultTrue;
+      data?: Byte[];
+      hashToDirectlySign?: Byte[];
+      protocolID: [SecurityLevel, ProtocolString5To400Bytes];
+      keyID: KeyIDStringUnder800Bytes;
+      privilegedReason?: DescriptionString5to50Bytes;
+      counterparty?: PubKeyHex | "self" | "anyone";
+      privileged?: BooleanDefaultFalse;
+    },
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<{ signature: Byte[] }> {
+    const paramWriter = new Utils.Writer();
+    paramWriter.write(
+      this.encodeKeyRelatedParams(
+        args.protocolID,
+        args.keyID,
+        args.counterparty,
+        args.privileged,
+        args.privilegedReason
+      )
+    );
+    if (typeof args.data === "object") {
+      paramWriter.writeUInt8(1);
+      paramWriter.writeVarIntNum(args.data.length);
+      paramWriter.write(args.data);
     } else {
-      paramWriter.writeUInt8(2)
-      paramWriter.write(args.hashToDirectlySign)
+      paramWriter.writeUInt8(2);
+      paramWriter.write(args.hashToDirectlySign);
     }
     // Serialize seekPermission
-    paramWriter.writeInt8(typeof args.seekPermission === 'boolean' ? args.seekPermission ? 1 : 0 : -1)
+    paramWriter.writeInt8(
+      typeof args.seekPermission === "boolean"
+        ? args.seekPermission
+          ? 1
+          : 0
+        : -1
+    );
     return {
-      signature: await this.transmit('createSignature', originator, paramWriter.toArray())
-    }
+      signature: await this.transmit(
+        "createSignature",
+        originator,
+        paramWriter.toArray()
+      ),
+    };
   }
 
-  async verifySignature(args: { seekPermission?: BooleanDefaultTrue, data?: Byte[], hashToDirectlyVerify?: Byte[], signature: Byte[], protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', forSelf?: BooleanDefaultFalse, privileged?: BooleanDefaultFalse }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{ valid: true }> {
-    const paramWriter = new Utils.Writer()
-    paramWriter.write(this.encodeKeyRelatedParams(args.protocolID, args.keyID, args.counterparty, args.privileged, args.privilegedReason))
-    if (typeof args.forSelf === 'boolean') {
-      paramWriter.writeInt8(args.forSelf ? 1 : 0)
+  async verifySignature(
+    args: {
+      seekPermission?: BooleanDefaultTrue;
+      data?: Byte[];
+      hashToDirectlyVerify?: Byte[];
+      signature: Byte[];
+      protocolID: [SecurityLevel, ProtocolString5To400Bytes];
+      keyID: KeyIDStringUnder800Bytes;
+      privilegedReason?: DescriptionString5to50Bytes;
+      counterparty?: PubKeyHex | "self" | "anyone";
+      forSelf?: BooleanDefaultFalse;
+      privileged?: BooleanDefaultFalse;
+    },
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<{ valid: true }> {
+    const paramWriter = new Utils.Writer();
+    paramWriter.write(
+      this.encodeKeyRelatedParams(
+        args.protocolID,
+        args.keyID,
+        args.counterparty,
+        args.privileged,
+        args.privilegedReason
+      )
+    );
+    if (typeof args.forSelf === "boolean") {
+      paramWriter.writeInt8(args.forSelf ? 1 : 0);
     } else {
-      paramWriter.writeInt8(-1)
-    }
-    paramWriter.writeVarIntNum(args.signature.length)
-    paramWriter.write(args.signature)
-    if (typeof args.data === 'object') {
-      paramWriter.writeUInt8(1)
-      paramWriter.writeVarIntNum(args.data.length)
-      paramWriter.write(args.data)
+      paramWriter.writeInt8(-1);
+    }
+    paramWriter.writeVarIntNum(args.signature.length);
+    paramWriter.write(args.signature);
+    if (typeof args.data === "object") {
+      paramWriter.writeUInt8(1);
+      paramWriter.writeVarIntNum(args.data.length);
+      paramWriter.write(args.data);
     } else {
-      paramWriter.writeUInt8(2)
-      paramWriter.write(args.hashToDirectlyVerify)
+      paramWriter.writeUInt8(2);
+      paramWriter.write(args.hashToDirectlyVerify);
     }
     // Serialize seekPermission
-    paramWriter.writeInt8(typeof args.seekPermission === 'boolean' ? args.seekPermission ? 1 : 0 : -1)
-    await this.transmit('verifySignature', originator, paramWriter.toArray())
-    return { valid: true }
+    paramWriter.writeInt8(
+      typeof args.seekPermission === "boolean"
+        ? args.seekPermission
+          ? 1
+          : 0
+        : -1
+    );
+    await this.transmit("verifySignature", originator, paramWriter.toArray());
+    return { valid: true };
   }
 
-  private encodeKeyRelatedParams(protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: boolean, privilegedReason?: string): number[] {
-    const paramWriter = new Utils.Writer()
-    paramWriter.writeUInt8(protocolID[0])
-    const protocolAsArray = Utils.toArray(protocolID[1], 'utf8')
-    paramWriter.writeVarIntNum(protocolAsArray.length)
-    paramWriter.write(protocolAsArray)
-    const keyIDAsArray = Utils.toArray(keyID, 'utf8')
-    paramWriter.writeVarIntNum(keyIDAsArray.length)
-    paramWriter.write(keyIDAsArray)
-    if (typeof counterparty !== 'string') {
-      paramWriter.writeUInt8(0)
-    } else if (counterparty === 'self') {
-      paramWriter.writeUInt8(11)
-    } else if (counterparty === 'anyone') {
-      paramWriter.writeUInt8(12)
+  private encodeKeyRelatedParams(
+    protocolID: [SecurityLevel, ProtocolString5To400Bytes],
+    keyID: KeyIDStringUnder800Bytes,
+    counterparty?: PubKeyHex | "self" | "anyone",
+    privileged?: boolean,
+    privilegedReason?: string
+  ): number[] {
+    const paramWriter = new Utils.Writer();
+    paramWriter.writeUInt8(protocolID[0]);
+    const protocolAsArray = Utils.toArray(protocolID[1], "utf8");
+    paramWriter.writeVarIntNum(protocolAsArray.length);
+    paramWriter.write(protocolAsArray);
+    const keyIDAsArray = Utils.toArray(keyID, "utf8");
+    paramWriter.writeVarIntNum(keyIDAsArray.length);
+    paramWriter.write(keyIDAsArray);
+    if (typeof counterparty !== "string") {
+      paramWriter.writeUInt8(0);
+    } else if (counterparty === "self") {
+      paramWriter.writeUInt8(11);
+    } else if (counterparty === "anyone") {
+      paramWriter.writeUInt8(12);
     } else {
-      paramWriter.write(Utils.toArray(counterparty, 'hex'))
+      paramWriter.write(Utils.toArray(counterparty, "hex"));
     }
-    paramWriter.write(this.encodePrivilegedParams(privileged, privilegedReason))
-    return paramWriter.toArray()
+    paramWriter.write(
+      this.encodePrivilegedParams(privileged, privilegedReason)
+    );
+    return paramWriter.toArray();
   }
 
   async acquireCertificate(
     args: AcquireCertificateArgs,
     originator?: OriginatorDomainNameStringUnder250Bytes
   ): Promise<AcquireCertificateResult> {
-    const paramWriter = new Utils.Writer()
-    paramWriter.write(Utils.toArray(args.type, 'base64'))
-    paramWriter.write(Utils.toArray(args.certifier, 'hex'))
+    const paramWriter = new Utils.Writer();
+    paramWriter.write(Utils.toArray(args.type, "base64"));
+    paramWriter.write(Utils.toArray(args.certifier, "hex"));
 
-    const fieldEntries = Object.entries(args.fields)
-    paramWriter.writeVarIntNum(fieldEntries.length)
+    const fieldEntries = Object.entries(args.fields);
+    paramWriter.writeVarIntNum(fieldEntries.length);
     for (const [key, value] of fieldEntries) {
-      const keyAsArray = Utils.toArray(key, 'utf8')
-      const valueAsArray = Utils.toArray(value, 'utf8')
+      const keyAsArray = Utils.toArray(key, "utf8");
+      const valueAsArray = Utils.toArray(value, "utf8");
 
-      paramWriter.writeVarIntNum(keyAsArray.length)
-      paramWriter.write(keyAsArray)
+      paramWriter.writeVarIntNum(keyAsArray.length);
+      paramWriter.write(keyAsArray);
 
-      paramWriter.writeVarIntNum(valueAsArray.length)
-      paramWriter.write(valueAsArray)
+      paramWriter.writeVarIntNum(valueAsArray.length);
+      paramWriter.write(valueAsArray);
     }
 
-    paramWriter.write(this.encodePrivilegedParams(args.privileged, args.privilegedReason))
-    paramWriter.writeUInt8(args.acquisitionProtocol === 'direct' ? 1 : 2)
+    paramWriter.write(
+      this.encodePrivilegedParams(args.privileged, args.privilegedReason)
+    );
+    paramWriter.writeUInt8(args.acquisitionProtocol === "direct" ? 1 : 2);
 
-    if (args.acquisitionProtocol === 'direct') {
-      paramWriter.write(Utils.toArray(args.serialNumber, 'base64'))
-      paramWriter.write(this.encodeOutpoint(args.revocationOutpoint))
-      const signatureAsArray = Utils.toArray(args.signature, 'hex')
-      paramWriter.writeVarIntNum(signatureAsArray.length)
-      paramWriter.write(signatureAsArray)
+    if (args.acquisitionProtocol === "direct") {
+      paramWriter.write(Utils.toArray(args.serialNumber, "base64"));
+      paramWriter.write(this.encodeOutpoint(args.revocationOutpoint));
+      const signatureAsArray = Utils.toArray(args.signature, "hex");
+      paramWriter.writeVarIntNum(signatureAsArray.length);
+      paramWriter.write(signatureAsArray);
 
-      const keyringRevealerAsArray = args.keyringRevealer !== 'certifier'
-        ? Utils.toArray(args.keyringRevealer, 'hex')
-        : [11]
-      paramWriter.write(keyringRevealerAsArray)
+      const keyringRevealerAsArray =
+        args.keyringRevealer !== "certifier"
+          ? Utils.toArray(args.keyringRevealer, "hex")
+          : [11];
+      paramWriter.write(keyringRevealerAsArray);
 
-      const keyringKeys = Object.keys(args.keyringForSubject)
-      paramWriter.writeVarIntNum(keyringKeys.length)
+      const keyringKeys = Object.keys(args.keyringForSubject);
+      paramWriter.writeVarIntNum(keyringKeys.length);
       for (let i = 0; i < keyringKeys.length; i++) {
-        const keyringKeysAsArray = Utils.toArray(keyringKeys[i], 'utf8')
-        paramWriter.writeVarIntNum(keyringKeysAsArray.length)
-        paramWriter.write(keyringKeysAsArray)
-        const keyringForSubjectAsArray = Utils.toArray(args.keyringForSubject[keyringKeys[i]], 'base64')
-        paramWriter.writeVarIntNum(keyringForSubjectAsArray.length)
-        paramWriter.write(keyringForSubjectAsArray)
+        const keyringKeysAsArray = Utils.toArray(keyringKeys[i], "utf8");
+        paramWriter.writeVarIntNum(keyringKeysAsArray.length);
+        paramWriter.write(keyringKeysAsArray);
+        const keyringForSubjectAsArray = Utils.toArray(
+          args.keyringForSubject[keyringKeys[i]],
+          "base64"
+        );
+        paramWriter.writeVarIntNum(keyringForSubjectAsArray.length);
+        paramWriter.write(keyringForSubjectAsArray);
       }
     } else {
-      const certifierUrlAsArray = Utils.toArray(args.certifierUrl, 'utf8')
-      paramWriter.writeVarIntNum(certifierUrlAsArray.length)
-      paramWriter.write(certifierUrlAsArray)
+      const certifierUrlAsArray = Utils.toArray(args.certifierUrl, "utf8");
+      paramWriter.writeVarIntNum(certifierUrlAsArray.length);
+      paramWriter.write(certifierUrlAsArray);
     }
 
-    const result = await this.transmit('acquireCertificate', originator, paramWriter.toArray())
-    const cert = Certificate.fromBinary(result)
+    const result = await this.transmit(
+      "acquireCertificate",
+      originator,
+      paramWriter.toArray()
+    );
+    const cert = Certificate.fromBinary(result);
     return {
       ...cert,
-      signature: cert.signature as string
-    }
+      signature: cert.signature as string,
+    };
   }
 
-  private encodePrivilegedParams(privileged?: boolean, privilegedReason?: string): number[] {
-    const paramWriter = new Utils.Writer()
-    if (typeof privileged === 'boolean') {
-      paramWriter.writeInt8(privileged ? 1 : 0)
+  private encodePrivilegedParams(
+    privileged?: boolean,
+    privilegedReason?: string
+  ): number[] {
+    const paramWriter = new Utils.Writer();
+    if (typeof privileged === "boolean") {
+      paramWriter.writeInt8(privileged ? 1 : 0);
     } else {
-      paramWriter.writeInt8(-1)
+      paramWriter.writeInt8(-1);
     }
-    if (typeof privilegedReason === 'string') {
-      const privilegedReasonAsArray = Utils.toArray(privilegedReason, 'utf8')
-      paramWriter.writeInt8(privilegedReasonAsArray.length)
-      paramWriter.write(privilegedReasonAsArray)
+    if (typeof privilegedReason === "string") {
+      const privilegedReasonAsArray = Utils.toArray(privilegedReason, "utf8");
+      paramWriter.writeInt8(privilegedReasonAsArray.length);
+      paramWriter.write(privilegedReasonAsArray);
     } else {
-      paramWriter.writeInt8(-1)
+      paramWriter.writeInt8(-1);
     }
-    return paramWriter.toArray()
+    return paramWriter.toArray();
   }
 
-  async listCertificates(args: { certifiers: PubKeyHex[], types: Base64String[], limit?: PositiveIntegerDefault10Max10000, offset?: PositiveIntegerOrZero, privileged?: BooleanDefaultFalse, privilegedReason?: DescriptionString5to50Bytes }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<ListCertificatesResult> {
-    const paramWriter = new Utils.Writer()
-    paramWriter.writeVarIntNum(args.certifiers.length)
+  async listCertificates(
+    args: {
+      certifiers: PubKeyHex[];
+      types: Base64String[];
+      limit?: PositiveIntegerDefault10Max10000;
+      offset?: PositiveIntegerOrZero;
+      privileged?: BooleanDefaultFalse;
+      privilegedReason?: DescriptionString5to50Bytes;
+    },
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<ListCertificatesResult> {
+    const paramWriter = new Utils.Writer();
+    paramWriter.writeVarIntNum(args.certifiers.length);
     for (let i = 0; i < args.certifiers.length; i++) {
-      paramWriter.write(Utils.toArray(args.certifiers[i], 'hex'))
+      paramWriter.write(Utils.toArray(args.certifiers[i], "hex"));
     }
 
-    paramWriter.writeVarIntNum(args.types.length)
+    paramWriter.writeVarIntNum(args.types.length);
     for (let i = 0; i < args.types.length; i++) {
-      paramWriter.write(Utils.toArray(args.types[i], 'base64'))
+      paramWriter.write(Utils.toArray(args.types[i], "base64"));
     }
-    if (typeof args.limit === 'number') {
-      paramWriter.writeVarIntNum(args.limit)
+    if (typeof args.limit === "number") {
+      paramWriter.writeVarIntNum(args.limit);
     } else {
-      paramWriter.writeVarIntNum(-1)
+      paramWriter.writeVarIntNum(-1);
     }
-    if (typeof args.offset === 'number') {
-      paramWriter.writeVarIntNum(args.offset)
+    if (typeof args.offset === "number") {
+      paramWriter.writeVarIntNum(args.offset);
     } else {
-      paramWriter.writeVarIntNum(-1)
-    }
-    paramWriter.write(this.encodePrivilegedParams(args.privileged, args.privilegedReason))
-    const result = await this.transmit('listCertificates', originator, paramWriter.toArray())
-    const resultReader = new Utils.Reader(result)
-    const totalCertificates = resultReader.readVarIntNum()
+      paramWriter.writeVarIntNum(-1);
+    }
+    paramWriter.write(
+      this.encodePrivilegedParams(args.privileged, args.privilegedReason)
+    );
+    const result = await this.transmit(
+      "listCertificates",
+      originator,
+      paramWriter.toArray()
+    );
+    const resultReader = new Utils.Reader(result);
+    const totalCertificates = resultReader.readVarIntNum();
     const certificates: Array<{
-      type: Base64String
-      subject: PubKeyHex
-      serialNumber: Base64String
-      certifier: PubKeyHex
-      revocationOutpoint: OutpointString
-      signature: HexString
-      fields: Record<CertificateFieldNameUnder50Bytes, Base64String>
-    }> = []
+      type: Base64String;
+      subject: PubKeyHex;
+      serialNumber: Base64String;
+      certifier: PubKeyHex;
+      revocationOutpoint: OutpointString;
+      signature: HexString;
+      fields: Record<CertificateFieldNameUnder50Bytes, Base64String>;
+    }> = [];
     for (let i = 0; i < totalCertificates; i++) {
-      const certificateLength = resultReader.readVarIntNum()
-      const certificateBin = resultReader.read(certificateLength)
-      const cert = Certificate.fromBinary(certificateBin)
+      const certificateLength = resultReader.readVarIntNum();
+      const certificateBin = resultReader.read(certificateLength);
+      const cert = Certificate.fromBinary(certificateBin);
       certificates.push({
         ...cert,
-        signature: cert.signature as string
-      })
+        signature: cert.signature as string,
+      });
     }
     return {
       totalCertificates,
-      certificates
-    }
+      certificates,
+    };
   }
 
-  async proveCertificate(args: ProveCertificateArgs, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<ProveCertificateResult> {
-    const paramWriter = new Utils.Writer()
-    const typeAsArray = Utils.toArray(args.certificate.type, 'base64')
-    paramWriter.write(typeAsArray)
-    const subjectAsArray = Utils.toArray(args.certificate.subject, 'hex')
-    paramWriter.write(subjectAsArray)
-    const serialNumberAsArray = Utils.toArray(args.certificate.serialNumber, 'base64')
-    paramWriter.write(serialNumberAsArray)
-    const certifierAsArray = Utils.toArray(args.certificate.certifier, 'hex')
-    paramWriter.write(certifierAsArray)
-    const revocationOutpointAsArray = this.encodeOutpoint(args.certificate.revocationOutpoint)
-    paramWriter.write(revocationOutpointAsArray)
-    const signatureAsArray = Utils.toArray(args.certificate.signature, 'hex')
-    paramWriter.writeVarIntNum(signatureAsArray.length)
-    paramWriter.write(signatureAsArray)
-    const fieldEntries = Object.entries(args.certificate.fields)
-    paramWriter.writeVarIntNum(fieldEntries.length)
+  async proveCertificate(
+    args: ProveCertificateArgs,
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<ProveCertificateResult> {
+    const paramWriter = new Utils.Writer();
+    const typeAsArray = Utils.toArray(args.certificate.type, "base64");
+    paramWriter.write(typeAsArray);
+    const subjectAsArray = Utils.toArray(args.certificate.subject, "hex");
+    paramWriter.write(subjectAsArray);
+    const serialNumberAsArray = Utils.toArray(
+      args.certificate.serialNumber,
+      "base64"
+    );
+    paramWriter.write(serialNumberAsArray);
+    const certifierAsArray = Utils.toArray(args.certificate.certifier, "hex");
+    paramWriter.write(certifierAsArray);
+    const revocationOutpointAsArray = this.encodeOutpoint(
+      args.certificate.revocationOutpoint
+    );
+    paramWriter.write(revocationOutpointAsArray);
+    const signatureAsArray = Utils.toArray(args.certificate.signature, "hex");
+    paramWriter.writeVarIntNum(signatureAsArray.length);
+    paramWriter.write(signatureAsArray);
+    const fieldEntries = Object.entries(args.certificate.fields);
+    paramWriter.writeVarIntNum(fieldEntries.length);
     for (const [key, value] of fieldEntries) {
-      const keyAsArray = Utils.toArray(key, 'utf8')
-      const valueAsArray = Utils.toArray(value, 'utf8')
-      paramWriter.writeVarIntNum(keyAsArray.length)
-      paramWriter.write(keyAsArray)
-      paramWriter.writeVarIntNum(valueAsArray.length)
-      paramWriter.write(valueAsArray)
-    }
-    paramWriter.writeVarIntNum(args.fieldsToReveal.length)
+      const keyAsArray = Utils.toArray(key, "utf8");
+      const valueAsArray = Utils.toArray(value, "utf8");
+      paramWriter.writeVarIntNum(keyAsArray.length);
+      paramWriter.write(keyAsArray);
+      paramWriter.writeVarIntNum(valueAsArray.length);
+      paramWriter.write(valueAsArray);
+    }
+    paramWriter.writeVarIntNum(args.fieldsToReveal.length);
     for (const field of args.fieldsToReveal) {
-      const fieldAsArray = Utils.toArray(field, 'utf8')
-      paramWriter.writeVarIntNum(fieldAsArray.length)
-      paramWriter.write(fieldAsArray)
-    }
-    paramWriter.write(Utils.toArray(args.verifier, 'hex'))
-    paramWriter.write(this.encodePrivilegedParams(args.privileged, args.privilegedReason))
-    const result = await this.transmit('proveCertificate', originator, paramWriter.toArray())
-    const resultReader = new Utils.Reader(result)
-    const numFields = resultReader.readVarIntNum()
-    const keyringForVerifier: Record<string, string> = {}
+      const fieldAsArray = Utils.toArray(field, "utf8");
+      paramWriter.writeVarIntNum(fieldAsArray.length);
+      paramWriter.write(fieldAsArray);
+    }
+    paramWriter.write(Utils.toArray(args.verifier, "hex"));
+    paramWriter.write(
+      this.encodePrivilegedParams(args.privileged, args.privilegedReason)
+    );
+    const result = await this.transmit(
+      "proveCertificate",
+      originator,
+      paramWriter.toArray()
+    );
+    const resultReader = new Utils.Reader(result);
+    const numFields = resultReader.readVarIntNum();
+    const keyringForVerifier: Record<string, string> = {};
     for (let i = 0; i < numFields; i++) {
-      const fieldKeyLength = resultReader.readVarIntNum()
-      const fieldKey = Utils.toUTF8(resultReader.read(fieldKeyLength))
-      const fieldValueLength = resultReader.readVarIntNum()
-      keyringForVerifier[fieldKey] = Utils.toBase64(resultReader.read(fieldValueLength))
+      const fieldKeyLength = resultReader.readVarIntNum();
+      const fieldKey = Utils.toUTF8(resultReader.read(fieldKeyLength));
+      const fieldValueLength = resultReader.readVarIntNum();
+      keyringForVerifier[fieldKey] = Utils.toBase64(
+        resultReader.read(fieldValueLength)
+      );
     }
     return {
-      keyringForVerifier
-    }
+      keyringForVerifier,
+    };
   }
 
-  async relinquishCertificate(args: { type: Base64String, serialNumber: Base64String, certifier: PubKeyHex }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{ relinquished: true }> {
-    const paramWriter = new Utils.Writer()
-    const typeAsArray = Utils.toArray(args.type, 'base64')
-    paramWriter.write(typeAsArray)
-    const serialNumberAsArray = Utils.toArray(args.serialNumber, 'base64')
-    paramWriter.write(serialNumberAsArray)
-    const certifierAsArray = Utils.toArray(args.certifier, 'hex')
-    paramWriter.write(certifierAsArray)
-    await this.transmit('relinquishCertificate', originator, paramWriter.toArray())
-    return { relinquished: true }
+  async relinquishCertificate(
+    args: {
+      type: Base64String;
+      serialNumber: Base64String;
+      certifier: PubKeyHex;
+    },
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<{ relinquished: true }> {
+    const paramWriter = new Utils.Writer();
+    const typeAsArray = Utils.toArray(args.type, "base64");
+    paramWriter.write(typeAsArray);
+    const serialNumberAsArray = Utils.toArray(args.serialNumber, "base64");
+    paramWriter.write(serialNumberAsArray);
+    const certifierAsArray = Utils.toArray(args.certifier, "hex");
+    paramWriter.write(certifierAsArray);
+    await this.transmit(
+      "relinquishCertificate",
+      originator,
+      paramWriter.toArray()
+    );
+    return { relinquished: true };
   }
 
   private parseDiscoveryResult(result: number[]): {
-    totalCertificates: number
+    totalCertificates: number;
     certificates: Array<{
-      type: Base64String
-      subject: PubKeyHex
-      serialNumber: Base64String
-      certifier: PubKeyHex
-      revocationOutpoint: OutpointString
-      signature: HexString
-      fields: Record<CertificateFieldNameUnder50Bytes, Base64String>
+      type: Base64String;
+      subject: PubKeyHex;
+      serialNumber: Base64String;
+      certifier: PubKeyHex;
+      revocationOutpoint: OutpointString;
+      signature: HexString;
+      fields: Record<CertificateFieldNameUnder50Bytes, Base64String>;
       certifierInfo: {
-        name: EntityNameStringMax100Bytes
-        iconUrl: EntityIconURLStringMax500Bytes
-        description: DescriptionString5to50Bytes
-        trust: PositiveIntegerMax10
-      }
-      publiclyRevealedKeyring: Record<CertificateFieldNameUnder50Bytes, Base64String>
-      decryptedFields: Record<CertificateFieldNameUnder50Bytes, string>
-    }>
+        name: EntityNameStringMax100Bytes;
+        iconUrl: EntityIconURLStringMax500Bytes;
+        description: DescriptionString5to50Bytes;
+        trust: PositiveIntegerMax10;
+      };
+      publiclyRevealedKeyring: Record<
+        CertificateFieldNameUnder50Bytes,
+        Base64String
+      >;
+      decryptedFields: Record<CertificateFieldNameUnder50Bytes, string>;
+    }>;
   } {
-    const resultReader = new Utils.Reader(result)
-    const totalCertificates = resultReader.readVarIntNum()
+    const resultReader = new Utils.Reader(result);
+    const totalCertificates = resultReader.readVarIntNum();
     const certificates: Array<{
-      type: Base64String
-      subject: PubKeyHex
-      serialNumber: Base64String
-      certifier: PubKeyHex
-      revocationOutpoint: OutpointString
-      signature: HexString
-      fields: Record<CertificateFieldNameUnder50Bytes, Base64String>
+      type: Base64String;
+      subject: PubKeyHex;
+      serialNumber: Base64String;
+      certifier: PubKeyHex;
+      revocationOutpoint: OutpointString;
+      signature: HexString;
+      fields: Record<CertificateFieldNameUnder50Bytes, Base64String>;
       certifierInfo: {
-        name: EntityNameStringMax100Bytes
-        iconUrl: EntityIconURLStringMax500Bytes
-        description: DescriptionString5to50Bytes
-        trust: PositiveIntegerMax10
-      }
-      publiclyRevealedKeyring: Record<CertificateFieldNameUnder50Bytes, Base64String>
-      decryptedFields: Record<CertificateFieldNameUnder50Bytes, string>
-    }> = []
+        name: EntityNameStringMax100Bytes;
+        iconUrl: EntityIconURLStringMax500Bytes;
+        description: DescriptionString5to50Bytes;
+        trust: PositiveIntegerMax10;
+      };
+      publiclyRevealedKeyring: Record<
+        CertificateFieldNameUnder50Bytes,
+        Base64String
+      >;
+      decryptedFields: Record<CertificateFieldNameUnder50Bytes, string>;
+    }> = [];
     for (let i = 0; i < totalCertificates; i++) {
-      const certBinLen = resultReader.readVarIntNum()
-      const certBin = resultReader.read(certBinLen)
-      const cert = Certificate.fromBinary(certBin)
-      const nameLength = resultReader.readVarIntNum()
-      const name = Utils.toUTF8(resultReader.read(nameLength))
-      const iconUrlLength = resultReader.readVarIntNum()
-      const iconUrl = Utils.toUTF8(resultReader.read(iconUrlLength))
-      const descriptionLength = resultReader.readVarIntNum()
-      const description = Utils.toUTF8(resultReader.read(descriptionLength))
-      const trust = resultReader.readUInt8()
-      const publiclyRevealedKeyring = {}
-      const numPublicKeyringEntries = resultReader.readVarIntNum()
+      const certBinLen = resultReader.readVarIntNum();
+      const certBin = resultReader.read(certBinLen);
+      const cert = Certificate.fromBinary(certBin);
+      const nameLength = resultReader.readVarIntNum();
+      const name = Utils.toUTF8(resultReader.read(nameLength));
+      const iconUrlLength = resultReader.readVarIntNum();
+      const iconUrl = Utils.toUTF8(resultReader.read(iconUrlLength));
+      const descriptionLength = resultReader.readVarIntNum();
+      const description = Utils.toUTF8(resultReader.read(descriptionLength));
+      const trust = resultReader.readUInt8();
+      const publiclyRevealedKeyring = {};
+      const numPublicKeyringEntries = resultReader.readVarIntNum();
       for (let j = 0; j < numPublicKeyringEntries; j++) {
-        const fieldKeyLen = resultReader.readVarIntNum()
-        const fieldKey = Utils.toUTF8(resultReader.read(fieldKeyLen))
-        const fieldValueLen = resultReader.readVarIntNum()
-        publiclyRevealedKeyring[fieldKey] = resultReader.read(fieldValueLen)
+        const fieldKeyLen = resultReader.readVarIntNum();
+        const fieldKey = Utils.toUTF8(resultReader.read(fieldKeyLen));
+        const fieldValueLen = resultReader.readVarIntNum();
+        publiclyRevealedKeyring[fieldKey] = resultReader.read(fieldValueLen);
       }
-      const decryptedFields = {}
-      const numDecryptedFields = resultReader.readVarIntNum()
+      const decryptedFields = {};
+      const numDecryptedFields = resultReader.readVarIntNum();
       for (let k = 0; k < numDecryptedFields; k++) {
-        const fieldKeyLen = resultReader.readVarIntNum()
-        const fieldKey = Utils.toUTF8(resultReader.read(fieldKeyLen))
-        const fieldValueLen = resultReader.readVarIntNum()
-        decryptedFields[fieldKey] = Utils.toUTF8(resultReader.read(fieldValueLen))
+        const fieldKeyLen = resultReader.readVarIntNum();
+        const fieldKey = Utils.toUTF8(resultReader.read(fieldKeyLen));
+        const fieldValueLen = resultReader.readVarIntNum();
+        decryptedFields[fieldKey] = Utils.toUTF8(
+          resultReader.read(fieldValueLen)
+        );
       }
       certificates.push({
         ...cert,
         signature: cert.signature as string,
         certifierInfo: { iconUrl, name, description, trust },
         publiclyRevealedKeyring,
-        decryptedFields
-      })
+        decryptedFields,
+      });
     }
     return {
       totalCertificates,
-      certificates
-    }
+      certificates,
+    };
   }
 
-  async discoverByIdentityKey(args: { seekPermission?: BooleanDefaultTrue, identityKey: PubKeyHex, limit?: PositiveIntegerDefault10Max10000, offset?: PositiveIntegerOrZero }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<DiscoverCertificatesResult> {
-    const paramWriter = new Utils.Writer()
-    paramWriter.write(Utils.toArray(args.identityKey, 'hex'))
-    if (typeof args.limit === 'number') {
-      paramWriter.writeVarIntNum(args.limit)
+  async discoverByIdentityKey(
+    args: {
+      seekPermission?: BooleanDefaultTrue;
+      identityKey: PubKeyHex;
+      limit?: PositiveIntegerDefault10Max10000;
+      offset?: PositiveIntegerOrZero;
+    },
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<DiscoverCertificatesResult> {
+    const paramWriter = new Utils.Writer();
+    paramWriter.write(Utils.toArray(args.identityKey, "hex"));
+    if (typeof args.limit === "number") {
+      paramWriter.writeVarIntNum(args.limit);
     } else {
-      paramWriter.writeVarIntNum(-1)
+      paramWriter.writeVarIntNum(-1);
     }
-    if (typeof args.offset === 'number') {
-      paramWriter.writeVarIntNum(args.offset)
+    if (typeof args.offset === "number") {
+      paramWriter.writeVarIntNum(args.offset);
     } else {
-      paramWriter.writeVarIntNum(-1)
+      paramWriter.writeVarIntNum(-1);
     }
     // Serialize seekPermission
-    paramWriter.writeInt8(typeof args.seekPermission === 'boolean' ? args.seekPermission ? 1 : 0 : -1)
-    const result = await this.transmit('discoverByIdentityKey', originator, paramWriter.toArray())
-    return this.parseDiscoveryResult(result)
+    paramWriter.writeInt8(
+      typeof args.seekPermission === "boolean"
+        ? args.seekPermission
+          ? 1
+          : 0
+        : -1
+    );
+    const result = await this.transmit(
+      "discoverByIdentityKey",
+      originator,
+      paramWriter.toArray()
+    );
+    return this.parseDiscoveryResult(result);
   }
 
-  async discoverByAttributes(args: { seekPermission?: BooleanDefaultTrue, attributes: Record<CertificateFieldNameUnder50Bytes, string>, limit?: PositiveIntegerDefault10Max10000, offset?: PositiveIntegerOrZero }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<DiscoverCertificatesResult> {
-    const paramWriter = new Utils.Writer()
-    const attributeKeys = Object.keys(args.attributes)
-    paramWriter.writeVarIntNum(attributeKeys.length)
+  async discoverByAttributes(
+    args: {
+      seekPermission?: BooleanDefaultTrue;
+      attributes: Record<CertificateFieldNameUnder50Bytes, string>;
+      limit?: PositiveIntegerDefault10Max10000;
+      offset?: PositiveIntegerOrZero;
+    },
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<DiscoverCertificatesResult> {
+    const paramWriter = new Utils.Writer();
+    const attributeKeys = Object.keys(args.attributes);
+    paramWriter.writeVarIntNum(attributeKeys.length);
     for (let i = 0; i < attributeKeys.length; i++) {
-      paramWriter.writeVarIntNum(attributeKeys[i].length)
-      paramWriter.write(Utils.toArray(attributeKeys[i], 'utf8'))
-      paramWriter.writeVarIntNum(args.attributes[attributeKeys[i]].length)
-      paramWriter.write(Utils.toArray(args.attributes[attributeKeys[i]], 'utf8'))
-    }
-    if (typeof args.limit === 'number') {
-      paramWriter.writeVarIntNum(args.limit)
+      paramWriter.writeVarIntNum(attributeKeys[i].length);
+      paramWriter.write(Utils.toArray(attributeKeys[i], "utf8"));
+      paramWriter.writeVarIntNum(args.attributes[attributeKeys[i]].length);
+      paramWriter.write(
+        Utils.toArray(args.attributes[attributeKeys[i]], "utf8")
+      );
+    }
+    if (typeof args.limit === "number") {
+      paramWriter.writeVarIntNum(args.limit);
     } else {
-      paramWriter.writeVarIntNum(-1)
+      paramWriter.writeVarIntNum(-1);
     }
-    if (typeof args.offset === 'number') {
-      paramWriter.writeVarIntNum(args.offset)
+    if (typeof args.offset === "number") {
+      paramWriter.writeVarIntNum(args.offset);
     } else {
-      paramWriter.writeVarIntNum(-1)
+      paramWriter.writeVarIntNum(-1);
     }
     // Serialize seekPermission
-    paramWriter.writeInt8(typeof args.seekPermission === 'boolean' ? args.seekPermission ? 1 : 0 : -1)
-    const result = await this.transmit('discoverByAttributes', originator, paramWriter.toArray())
-    return this.parseDiscoveryResult(result)
+    paramWriter.writeInt8(
+      typeof args.seekPermission === "boolean"
+        ? args.seekPermission
+          ? 1
+          : 0
+        : -1
+    );
+    const result = await this.transmit(
+      "discoverByAttributes",
+      originator,
+      paramWriter.toArray()
+    );
+    return this.parseDiscoveryResult(result);
   }
 
-  async isAuthenticated(args: {}, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{ authenticated: true }> {
-    const result = await this.transmit('isAuthenticated', originator)
+  async isAuthenticated(
+    args: {},
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<{ authenticated: true }> {
+    const result = await this.transmit("isAuthenticated", originator);
     // @ts-ignore
-    return { authenticated: !!result[0] }
+    return { authenticated: !!result[0] };
   }
 
-  async waitForAuthentication(args: {}, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{ authenticated: true }> {
-    await this.transmit('waitForAuthentication', originator)
-    return { authenticated: true }
+  async waitForAuthentication(
+    args: {},
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<{ authenticated: true }> {
+    await this.transmit("waitForAuthentication", originator);
+    return { authenticated: true };
   }
 
-  async getHeight(args: {}, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{ height: PositiveInteger }> {
-    const result = await this.transmit('getHeight', originator)
-    const resultReader = new Utils.Reader(result)
+  async getHeight(
+    args: {},
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<{ height: PositiveInteger }> {
+    const result = await this.transmit("getHeight", originator);
+    const resultReader = new Utils.Reader(result);
     return {
-      height: resultReader.readVarIntNum()
-    }
+      height: resultReader.readVarIntNum(),
+    };
   }
 
-  async getHeaderForHeight(args: { height: PositiveInteger }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{ header: HexString }> {
-    const paramWriter = new Utils.Writer()
-    paramWriter.writeVarIntNum(args.height)
-    const header = await this.transmit('getHeaderForHeight', originator, paramWriter.toArray())
+  async getHeaderForHeight(
+    args: { height: PositiveInteger },
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<{ header: HexString }> {
+    const paramWriter = new Utils.Writer();
+    paramWriter.writeVarIntNum(args.height);
+    const header = await this.transmit(
+      "getHeaderForHeight",
+      originator,
+      paramWriter.toArray()
+    );
     return {
-      header: Utils.toHex(header)
-    }
+      header: Utils.toHex(header),
+    };
   }
 
-  async getNetwork(args: {}, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{ network: 'mainnet' | 'testnet' }> {
-    const net = await this.transmit('getNetwork', originator)
+  async getNetwork(
+    args: {},
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<{ network: "mainnet" | "testnet" }> {
+    const net = await this.transmit("getNetwork", originator);
     return {
-      network: net[0] === 0 ? 'mainnet' : 'testnet'
-    }
+      network: net[0] === 0 ? "mainnet" : "testnet",
+    };
   }
 
-  async getVersion(args: {}, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{ version: VersionString7To30Bytes }> {
-    const version = await this.transmit('getVersion', originator)
+  async getVersion(
+    args: {},
+    originator?: OriginatorDomainNameStringUnder250Bytes
+  ): Promise<{ version: VersionString7To30Bytes }> {
+    const version = await this.transmit("getVersion", originator);
     return {
-      version: Utils.toUTF8(version)
-    }
+      version: Utils.toUTF8(version),
+    };
   }
 }