@bsv/sdk 1.3.9 → 1.3.11

package/src/auth/certificates/__tests/VerifiableCertificate.test.ts

@@ -2,14 +2,15 @@ import { VerifiableCertificate } from '../../../../dist/cjs/src/auth/certificate
 import { PrivateKey, SymmetricKey, Utils } from '../../../../dist/cjs/src/primitives/index.js'
 import { CompletedProtoWallet } from '../../../../dist/cjs/src/auth/certificates/__tests/CompletedProtoWallet.js'
 import { Certificate } from '../../../../dist/cjs/src/auth/certificates/index.js'
+import { MasterCertificate } from '../../../../dist/cjs/src/auth/certificates/MasterCertificate.js'
 
 describe('VerifiableCertificate', () => {
   const subjectPrivateKey = PrivateKey.fromRandom()
-  const subjectPubKey = subjectPrivateKey.toPublicKey().toString()
+  const subjectIdentityKey = subjectPrivateKey.toPublicKey().toString()
   const certifierPrivateKey = PrivateKey.fromRandom()
-  const certifierPubKey = certifierPrivateKey.toPublicKey().toString()
+  const certifierIdentityKey = certifierPrivateKey.toPublicKey().toString()
   const verifierPrivateKey = PrivateKey.fromRandom()
-  const verifierPubKey = verifierPrivateKey.toPublicKey().toString()
+  const verifierIdentityKey = verifierPrivateKey.toPublicKey().toString()
 
   const subjectWallet = new CompletedProtoWallet(subjectPrivateKey)
   const verifierWallet = new CompletedProtoWallet(verifierPrivateKey)
@@ -28,34 +29,28 @@ describe('VerifiableCertificate', () => {
 
   beforeEach(async () => {
     // For each test, we'll build a fresh VerifiableCertificate with valid encryption
-    const certificateFields = {}
-    const keyring = {}
-
-    for (const fieldName in plaintextFields) {
-      // Generate a random field symmetric key
-      const fieldSymKey = SymmetricKey.fromRandom()
-      // Encrypt the field's plaintext
-      const encryptedFieldValue = fieldSymKey.encrypt(Utils.toArray(plaintextFields[fieldName], 'utf8'))
-      certificateFields[fieldName] = Utils.toBase64(encryptedFieldValue as number[])
-
-      // Now encrypt the fieldSymKey for the verifier
-      const { ciphertext: encryptedRevelationKey } = await subjectWallet.encrypt({
-        plaintext: fieldSymKey.toArray(),
-        ...Certificate.getCertificateFieldEncryptionDetails(sampleSerialNumber, fieldName),
-        counterparty: verifierPubKey
-      })
-      keyring[fieldName] = Utils.toBase64(encryptedRevelationKey)
-    }
-
+    const { certificateFields, masterKeyring } = await MasterCertificate.createCertificateFields(
+      subjectWallet,
+      certifierIdentityKey,
+      plaintextFields
+    )
+    const keyringForVerifier = await MasterCertificate.createKeyringForVerifier(
+      subjectWallet,
+      certifierIdentityKey,
+      verifierIdentityKey,
+      certificateFields,
+      Object.keys(certificateFields),
+      masterKeyring,
+      sampleSerialNumber
+    )
     verifiableCert = new VerifiableCertificate(
       sampleType,
       sampleSerialNumber,
-      subjectPubKey,
-      certifierPubKey,
+      subjectIdentityKey,
+      certifierIdentityKey,
       sampleRevocationOutpoint,
       certificateFields,
-      undefined, // signature
-      keyring
+      keyringForVerifier
     )
   })
 
@@ -64,8 +59,8 @@ describe('VerifiableCertificate', () => {
       expect(verifiableCert).toBeInstanceOf(VerifiableCertificate)
       expect(verifiableCert.type).toEqual(sampleType)
       expect(verifiableCert.serialNumber).toEqual(sampleSerialNumber)
-      expect(verifiableCert.subject).toEqual(subjectPubKey)
-      expect(verifiableCert.certifier).toEqual(certifierPubKey)
+      expect(verifiableCert.subject).toEqual(subjectIdentityKey)
+      expect(verifiableCert.certifier).toEqual(certifierIdentityKey)
       expect(verifiableCert.revocationOutpoint).toEqual(sampleRevocationOutpoint)
       expect(verifiableCert.fields).toBeDefined()
       expect(verifiableCert.keyring).toBeDefined()
@@ -97,8 +92,8 @@ describe('VerifiableCertificate', () => {
         verifiableCert.certifier,
         verifiableCert.revocationOutpoint,
         fields,
-        verifiableCert.signature,
-        {} // empty
+        {}, // empty
+        verifiableCert.signature
       )
 
       await expect(emptyKeyringCert.decryptFields(verifierWallet)).rejects.toThrow(

package/src/auth/utils/__tests/cryptononce.test.ts

@@ -1,16 +1,17 @@
-import { PrivateKey } from '../../../../dist/cjs/src/primitives/index.js'
-import { ProtoWallet } from '../../../../dist/cjs/src/wallet/index.js'
-import { Wallet } from '../../../../dist/cjs/src/wallet/Wallet.interfaces.js'
+import { PrivateKey, Random, Utils } from '../../../../dist/cjs/src/primitives/index.js'
+import { ProtoWallet } from '../../../../dist/cjs/src/wallet/ProtoWallet.js'
+import { WalletInterface } from '../../../../dist/cjs/src/wallet/Wallet.interfaces.js'
 import { createNonce } from '../../../../dist/cjs/src/auth/utils/createNonce.js'
 import { verifyNonce } from '../../../../dist/cjs/src/auth/utils/verifyNonce.js'
+import { hash256 } from '../../../../dist/cjs/src/primitives/Hash.js'
 
 describe('createNonce', () => {
-  let mockWallet: Wallet
+  let mockWallet: WalletInterface
 
   beforeEach(() => {
     mockWallet = {
       createHmac: jest.fn().mockResolvedValue({ hmac: new Uint8Array(16) }),
-    } as unknown as Wallet
+    } as unknown as WalletInterface
   })
 
   afterEach(() => {
@@ -31,13 +32,13 @@ describe('createNonce', () => {
 })
 
 describe('verifyNonce', () => {
-  let mockWallet: Wallet
+  let mockWallet: WalletInterface
 
   beforeEach(() => {
     mockWallet = {
       createHmac: jest.fn().mockResolvedValue({ hmac: new Uint8Array(16) }),
       verifyHmac: jest.fn().mockResolvedValue({ valid: true }),
-    } as unknown as Wallet
+    } as unknown as WalletInterface
   })
 
   afterEach(() => {
@@ -81,4 +82,38 @@ describe('verifyNonce', () => {
 
     expect(isValid).toEqual(true)
   })
+
+  it('SerialNumber use-case', async () => {
+    const clientWallet = new ProtoWallet(PrivateKey.fromRandom())
+    const serverWallet = new ProtoWallet(PrivateKey.fromRandom())
+
+    // Client creates a random nonce that the server can verify
+    const clientNonce = await createNonce(clientWallet, (await serverWallet.getPublicKey({ identityKey: true })).publicKey)
+    // The server verifies the client created the nonce provided
+    await verifyNonce(clientNonce, serverWallet, (await clientWallet.getPublicKey({ identityKey: true })).publicKey)
+    // Server creates a random nonce that the client can verify
+    const serverNonce = await createNonce(serverWallet, (await clientWallet.getPublicKey({ identityKey: true })).publicKey)
+    // The server compute a serial number from the client and server nonce
+    const { hmac: serialNumber } = await serverWallet.createHmac({
+      data: clientNonce + serverNonce,
+      protocolID: [2, 'certificate creation'],
+      keyID: serverNonce + clientNonce,
+      counterparty: (await clientWallet.getPublicKey({ identityKey: true })).publicKey
+    })
+
+    // Client verifies server's nonce
+    await verifyNonce(serverNonce, clientWallet, (await serverWallet.getPublicKey({ identityKey: true })).publicKey)
+
+    // Client verifies the server included their nonce
+    const { valid } = await clientWallet.verifyHmac({
+      hmac: serialNumber,
+      data: clientNonce + serverNonce,
+      protocolID: [2, 'certificate creation'],
+      keyID: serverNonce + clientNonce,
+      counterparty: (await serverWallet.getPublicKey({ identityKey: true })).publicKey,
+    })
+
+    console.log(Utils.toBase64(serialNumber))
+    expect(valid).toEqual(true)
+  })
 })

package/src/auth/utils/createNonce.ts

@@ -1,15 +1,21 @@
-import { Utils, Random, WalletInterface } from '../../../mod.js'
+import { Utils, Random, WalletInterface, WalletCounterparty } from '../../../mod.js'
 
 /**
- * Creates a nonce derived from a privateKey
+ * Creates a nonce derived from a wallet
  * @param wallet
+ * @param counterparty - The counterparty to the nonce creation. Defaults to 'self'.
  * @returns A random nonce derived with a wallet
  */
-export async function createNonce(wallet: WalletInterface): Promise<string> {
+export async function createNonce(wallet: WalletInterface, counterparty: WalletCounterparty = 'self'): Promise<string> {
   // Generate 16 random bytes for the first half of the data
   const firstHalf = Random(16)
   // Create an sha256 HMAC
-  const { hmac } = await wallet.createHmac({ protocolID: [2, 'server hmac'], keyID: Utils.toUTF8(firstHalf), data: firstHalf, counterparty: 'self' })
+  const { hmac } = await wallet.createHmac({
+    protocolID: [2, 'server hmac'],
+    keyID: Utils.toUTF8(firstHalf),
+    data: firstHalf,
+    counterparty
+  })
   // Concatenate firstHalf and secondHalf as the nonce bytes
   const nonceBytes = [...firstHalf, ...hmac]
   return Utils.toBase64(nonceBytes)

package/src/auth/utils/getVerifiableCertificates.ts

@@ -33,8 +33,8 @@ export const getVerifiableCertificates = async (wallet: WalletInterface, request
         certificate.certifier,
         certificate.revocationOutpoint,
         certificate.fields,
-        certificate.signature,
-        keyringForVerifier
+        keyringForVerifier,
+        certificate.signature
       )
     }))
 }

package/src/auth/utils/validateCertificates.ts

@@ -24,8 +24,8 @@ export const validateCertificates = async (verifierWallet: WalletInterface, mess
       incomingCert.certifier,
       incomingCert.revocationOutpoint,
       incomingCert.fields,
-      incomingCert.signature,
-      incomingCert.keyring
+      incomingCert.keyring,
+      incomingCert.signature
     )
     const isValidCert = await certToVerify.verify()
     if (!isValidCert) {

package/src/auth/utils/verifyNonce.ts

@@ -1,12 +1,13 @@
-import { Utils, WalletInterface } from '../../../mod.js'
+import { Utils, WalletCounterparty, WalletInterface } from '../../../mod.js'
 
 /**
  * Verifies a nonce derived from a wallet
  * @param nonce - A nonce to verify as a base64 string.
  * @param wallet
+ * @param counterparty - The counterparty to the nonce creation. Defaults to 'self'.
  * @returns The status of the validation
  */
-export async function verifyNonce(nonce: string, wallet: WalletInterface): Promise<boolean> {
+export async function verifyNonce(nonce: string, wallet: WalletInterface, counterparty: WalletCounterparty = 'self'): Promise<boolean> {
   // Convert nonce from base64 string to Uint8Array
   const buffer = Utils.toArray(nonce, 'base64')
 
@@ -20,7 +21,7 @@ export async function verifyNonce(nonce: string, wallet: WalletInterface): Promi
     hmac,
     protocolID: [2, 'server hmac'],
     keyID: Utils.toUTF8(data),
-    counterparty: 'self'
+    counterparty
   })
 
   return valid

package/src/overlay-tools/OverlayAdminTokenTemplate.ts

@@ -15,7 +15,7 @@ export default class OverlayAdminTokenTemplate implements ScriptTemplate {
      * @param script Locking script comprising a SHIP or SLAP token to decode
      * @returns Decoded SHIP or SLAP advertisement
      */
-  static decode(script: LockingScript): { protocol: 'SHIP' | 'SLAP', identityKey: string, domain: string, topicOrService: string } {
+  static decode (script: LockingScript): { protocol: 'SHIP' | 'SLAP', identityKey: string, domain: string, topicOrService: string } {
     const result = PushDrop.decode(script)
     if (result.fields.length < 4) {
       throw new Error('Invalid SHIP/SLAP advertisement!')
@@ -39,7 +39,7 @@ export default class OverlayAdminTokenTemplate implements ScriptTemplate {
      * Constructs a new Overlay Admin template instance
      * @param wallet Wallet to use for locking and unlocking
      */
-  constructor(wallet: WalletInterface) {
+  constructor (wallet: WalletInterface) {
     this.pushDrop = new PushDrop(wallet)
   }
 
@@ -50,7 +50,7 @@ export default class OverlayAdminTokenTemplate implements ScriptTemplate {
      * @param topicOrService Topic or service to advertise
      * @returns Locking script comprising the advertisement token
      */
-  async lock(protocol: 'SHIP' | 'SLAP', domain: string, topicOrService: string): Promise<LockingScript> {
+  async lock (protocol: 'SHIP' | 'SLAP', domain: string, topicOrService: string): Promise<LockingScript> {
     const { publicKey: identityKey } = await this.pushDrop.wallet.getPublicKey({ identityKey: true })
     return await this.pushDrop.lock(
       [
@@ -70,7 +70,7 @@ export default class OverlayAdminTokenTemplate implements ScriptTemplate {
      * @param protocol SHIP or SLAP, depending on the token to unlock
      * @returns Script unlocker capable of unlocking the advertisement token
      */
-  unlock(protocol: 'SHIP' | 'SLAP'): {
+  unlock (protocol: 'SHIP' | 'SLAP'): {
     sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>
     estimateLength: (tx: Transaction, inputIndex: number) => Promise<number>
   } {

package/src/wallet/ProtoWallet.ts

@@ -35,14 +35,14 @@ import {
 export class ProtoWallet {
   keyDeriver: KeyDeriverApi
 
-  constructor(rootKeyOrKeyDeriver: PrivateKey | 'anyone' | KeyDeriverApi) {
+  constructor (rootKeyOrKeyDeriver: PrivateKey | 'anyone' | KeyDeriverApi) {
     if (typeof (rootKeyOrKeyDeriver as KeyDeriver).identityKey !== 'string') {
       rootKeyOrKeyDeriver = new KeyDeriver(rootKeyOrKeyDeriver as PrivateKey | 'anyone')
     }
     this.keyDeriver = rootKeyOrKeyDeriver as KeyDeriver
   }
 
-  async getPublicKey(
+  async getPublicKey (
     args: GetPublicKeyArgs
   ): Promise<{ publicKey: PubKeyHex }> {
     if (args.identityKey) {
@@ -64,7 +64,7 @@ export class ProtoWallet {
     }
   }
 
-  async revealCounterpartyKeyLinkage(
+  async revealCounterpartyKeyLinkage (
     args: RevealCounterpartyKeyLinkageArgs
   ): Promise<RevealCounterpartyKeyLinkageResult> {
     const { publicKey: identityKey } = await this.getPublicKey({ identityKey: true })
@@ -98,7 +98,7 @@ export class ProtoWallet {
     }
   }
 
-  async revealSpecificKeyLinkage(
+  async revealSpecificKeyLinkage (
     args: RevealSpecificKeyLinkageArgs
   ): Promise<RevealSpecificKeyLinkageResult> {
     const { publicKey: identityKey } = await this.getPublicKey({ identityKey: true })
@@ -131,7 +131,7 @@ export class ProtoWallet {
     }
   }
 
-  async encrypt(
+  async encrypt (
     args: WalletEncryptArgs
   ): Promise<WalletEncryptResult> {
     const key = this.keyDeriver.deriveSymmetricKey(
@@ -142,7 +142,7 @@ export class ProtoWallet {
     return { ciphertext: key.encrypt(args.plaintext) as number[] }
   }
 
-  async decrypt(
+  async decrypt (
     args: WalletDecryptArgs
   ): Promise<WalletDecryptResult> {
     const key = this.keyDeriver.deriveSymmetricKey(
@@ -153,7 +153,7 @@ export class ProtoWallet {
     return { plaintext: key.decrypt(args.ciphertext) as number[] }
   }
 
-  async createHmac(
+  async createHmac (
     args: CreateHmacArgs
   ): Promise<CreateHmacResult> {
     const key = this.keyDeriver.deriveSymmetricKey(
@@ -164,7 +164,7 @@ export class ProtoWallet {
     return { hmac: Hash.sha256hmac(key.toArray(), args.data) }
   }
 
-  async verifyHmac(
+  async verifyHmac (
     args: VerifyHmacArgs
   ): Promise<VerifyHmacResult> {
     const key = this.keyDeriver.deriveSymmetricKey(
@@ -181,7 +181,7 @@ export class ProtoWallet {
     return { valid }
   }
 
-  async createSignature(
+  async createSignature (
     args: CreateSignatureArgs
   ): Promise<CreateSignatureResult> {
     if (!args.hashToDirectlySign && !args.data) {
@@ -196,7 +196,7 @@ export class ProtoWallet {
     return { signature: ECDSA.sign(new BigNumber(hash), key, true).toDER() as number[] }
   }
 
-  async verifySignature(
+  async verifySignature (
     args: VerifySignatureArgs
   ): Promise<VerifySignatureResult> {
     if (!args.hashToDirectlyVerify && !args.data) {

package/src/wallet/WalletClient.ts

@@ -13,7 +13,7 @@ const MAX_XDM_RESPONSE_WAIT = 200
 export default class WalletClient implements WalletInterface {
   public substrate: 'auto' | WalletInterface
   originator?: OriginatorDomainNameStringUnder250Bytes
-  constructor(substrate: 'auto' | 'Cicada' | 'XDM' | 'window.CWI' | 'json-api' | WalletInterface = 'auto', originator?: OriginatorDomainNameStringUnder250Bytes) {
+  constructor (substrate: 'auto' | 'Cicada' | 'XDM' | 'window.CWI' | 'json-api' | WalletInterface = 'auto', originator?: OriginatorDomainNameStringUnder250Bytes) {
     if (substrate === 'Cicada') substrate = new WalletWireTransceiver(new HTTPWalletWire(originator))
     if (substrate === 'window.CWI') substrate = new WindowCWISubstrate()
     if (substrate === 'XDM') substrate = new XDMSubstrate()
@@ -22,7 +22,7 @@ export default class WalletClient implements WalletInterface {
     this.originator = originator
   }
 
-  async connectToSubstrate() {
+  async connectToSubstrate () {
     if (typeof this.substrate === 'object') {
       return // substrate is already connected
     }
@@ -68,141 +68,141 @@ export default class WalletClient implements WalletInterface {
     }
   }
 
-  async createAction(args: CreateActionArgs): Promise<CreateActionResult> {
+  async createAction (args: CreateActionArgs): Promise<CreateActionResult> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).createAction(args, this.originator)
   }
 
-  async signAction(args: SignActionArgs): Promise<SignActionResult> {
+  async signAction (args: SignActionArgs): Promise<SignActionResult> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).signAction(args, this.originator)
   }
 
-  async abortAction(args: { reference: Base64String }): Promise<{ aborted: true }> {
+  async abortAction (args: { reference: Base64String }): Promise<{ aborted: true }> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).abortAction(args, this.originator)
   }
 
-  async listActions(args: ListActionsArgs): Promise<ListActionsResult> {
+  async listActions (args: ListActionsArgs): Promise<ListActionsResult> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).listActions(args, this.originator)
   }
 
-  async internalizeAction(args: InternalizeActionArgs): Promise<{ accepted: true }> {
+  async internalizeAction (args: InternalizeActionArgs): Promise<{ accepted: true }> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).internalizeAction(args, this.originator)
   }
 
-  async listOutputs(args: ListOutputsArgs): Promise<ListOutputsResult> {
+  async listOutputs (args: ListOutputsArgs): Promise<ListOutputsResult> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).listOutputs(args, this.originator)
   }
 
-  async relinquishOutput(args: { basket: BasketStringUnder300Bytes, output: OutpointString }): Promise<{ relinquished: true }> {
+  async relinquishOutput (args: { basket: BasketStringUnder300Bytes, output: OutpointString }): Promise<{ relinquished: true }> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).relinquishOutput(args, this.originator)
   }
 
-  async getPublicKey(args: { identityKey?: true, protocolID?: [SecurityLevel, ProtocolString5To400Bytes], keyID?: KeyIDStringUnder800Bytes, privileged?: BooleanDefaultFalse, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', forSelf?: BooleanDefaultFalse }): Promise<{ publicKey: PubKeyHex }> {
+  async getPublicKey (args: { identityKey?: true, protocolID?: [SecurityLevel, ProtocolString5To400Bytes], keyID?: KeyIDStringUnder800Bytes, privileged?: BooleanDefaultFalse, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', forSelf?: BooleanDefaultFalse }): Promise<{ publicKey: PubKeyHex }> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).getPublicKey(args, this.originator)
   }
 
-  async revealCounterpartyKeyLinkage(args: { counterparty: PubKeyHex, verifier: PubKeyHex, privilegedReason?: DescriptionString5to50Bytes, privileged?: BooleanDefaultFalse }): Promise<{ prover: PubKeyHex, verifier: PubKeyHex, counterparty: PubKeyHex, revelationTime: ISOTimestampString, encryptedLinkage: Byte[], encryptedLinkageProof: Byte[] }> {
+  async revealCounterpartyKeyLinkage (args: { counterparty: PubKeyHex, verifier: PubKeyHex, privilegedReason?: DescriptionString5to50Bytes, privileged?: BooleanDefaultFalse }): Promise<{ prover: PubKeyHex, verifier: PubKeyHex, counterparty: PubKeyHex, revelationTime: ISOTimestampString, encryptedLinkage: Byte[], encryptedLinkageProof: Byte[] }> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).revealCounterpartyKeyLinkage(args, this.originator)
   }
 
-  async revealSpecificKeyLinkage(args: { counterparty: PubKeyHex, verifier: PubKeyHex, protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, privileged?: BooleanDefaultFalse }): Promise<{ prover: PubKeyHex, verifier: PubKeyHex, counterparty: PubKeyHex, protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, encryptedLinkage: Byte[], encryptedLinkageProof: Byte[], proofType: Byte }> {
+  async revealSpecificKeyLinkage (args: { counterparty: PubKeyHex, verifier: PubKeyHex, protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, privileged?: BooleanDefaultFalse }): Promise<{ prover: PubKeyHex, verifier: PubKeyHex, counterparty: PubKeyHex, protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, encryptedLinkage: Byte[], encryptedLinkageProof: Byte[], proofType: Byte }> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).revealSpecificKeyLinkage(args, this.originator)
   }
 
-  async encrypt(args: { plaintext: Byte[], protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }): Promise<{ ciphertext: Byte[] }> {
+  async encrypt (args: { plaintext: Byte[], protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }): Promise<{ ciphertext: Byte[] }> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).encrypt(args, this.originator)
   }
 
-  async decrypt(args: { ciphertext: Byte[], protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }): Promise<{ plaintext: Byte[] }> {
+  async decrypt (args: { ciphertext: Byte[], protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }): Promise<{ plaintext: Byte[] }> {
     return await (this.substrate as WalletInterface).decrypt(args, this.originator)
   }
 
-  async createHmac(args: { data: Byte[], protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }): Promise<{ hmac: Byte[] }> {
+  async createHmac (args: { data: Byte[], protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }): Promise<{ hmac: Byte[] }> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).createHmac(args, this.originator)
   }
 
-  async verifyHmac(args: { data: Byte[], hmac: Byte[], protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }): Promise<{ valid: true }> {
+  async verifyHmac (args: { data: Byte[], hmac: Byte[], protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }): Promise<{ valid: true }> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).verifyHmac(args, this.originator)
   }
 
-  async createSignature(args: { data?: Byte[], hashToDirectlySign?: Byte[], protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }): Promise<{ signature: Byte[] }> {
+  async createSignature (args: { data?: Byte[], hashToDirectlySign?: Byte[], protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }): Promise<{ signature: Byte[] }> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).createSignature(args, this.originator)
   }
 
-  async verifySignature(args: { data?: Byte[], hashToDirectlyVerify?: Byte[], signature: Byte[], protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', forSelf?: BooleanDefaultFalse, privileged?: BooleanDefaultFalse }): Promise<{ valid: true }> {
+  async verifySignature (args: { data?: Byte[], hashToDirectlyVerify?: Byte[], signature: Byte[], protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', forSelf?: BooleanDefaultFalse, privileged?: BooleanDefaultFalse }): Promise<{ valid: true }> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).verifySignature(args, this.originator)
   }
 
-  async acquireCertificate(args: AcquireCertificateArgs): Promise<AcquireCertificateResult> {
+  async acquireCertificate (args: AcquireCertificateArgs): Promise<AcquireCertificateResult> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).acquireCertificate(args, this.originator)
   }
 
-  async listCertificates(args: { certifiers: PubKeyHex[], types: Base64String[], limit?: PositiveIntegerDefault10Max10000, offset?: PositiveIntegerOrZero, privileged?: BooleanDefaultFalse, privilegedReason?: DescriptionString5to50Bytes }): Promise<ListCertificatesResult> {
+  async listCertificates (args: { certifiers: PubKeyHex[], types: Base64String[], limit?: PositiveIntegerDefault10Max10000, offset?: PositiveIntegerOrZero, privileged?: BooleanDefaultFalse, privilegedReason?: DescriptionString5to50Bytes }): Promise<ListCertificatesResult> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).listCertificates(args, this.originator)
   }
 
-  async proveCertificate(args: ProveCertificateArgs): Promise<ProveCertificateResult> {
+  async proveCertificate (args: ProveCertificateArgs): Promise<ProveCertificateResult> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).proveCertificate(args, this.originator)
   }
 
-  async relinquishCertificate(args: { type: Base64String, serialNumber: Base64String, certifier: PubKeyHex }): Promise<{ relinquished: true }> {
+  async relinquishCertificate (args: { type: Base64String, serialNumber: Base64String, certifier: PubKeyHex }): Promise<{ relinquished: true }> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).relinquishCertificate(args, this.originator)
   }
 
-  async discoverByIdentityKey(args: { identityKey: PubKeyHex, limit?: PositiveIntegerDefault10Max10000, offset?: PositiveIntegerOrZero }): Promise<DiscoverCertificatesResult> {
+  async discoverByIdentityKey (args: { identityKey: PubKeyHex, limit?: PositiveIntegerDefault10Max10000, offset?: PositiveIntegerOrZero }): Promise<DiscoverCertificatesResult> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).discoverByIdentityKey(args, this.originator)
   }
 
-  async discoverByAttributes(args: { attributes: Record<CertificateFieldNameUnder50Bytes, string>, limit?: PositiveIntegerDefault10Max10000, offset?: PositiveIntegerOrZero }): Promise<DiscoverCertificatesResult> {
+  async discoverByAttributes (args: { attributes: Record<CertificateFieldNameUnder50Bytes, string>, limit?: PositiveIntegerDefault10Max10000, offset?: PositiveIntegerOrZero }): Promise<DiscoverCertificatesResult> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).discoverByAttributes(args, this.originator)
   }
 
-  async isAuthenticated(args: {} = {}): Promise<AuthenticatedResult> {
+  async isAuthenticated (args: {} = {}): Promise<AuthenticatedResult> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).isAuthenticated(args, this.originator)
   }
 
-  async waitForAuthentication(args: {} = {}): Promise<{ authenticated: true }> {
+  async waitForAuthentication (args: {} = {}): Promise<{ authenticated: true }> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).waitForAuthentication(args, this.originator)
   }
 
-  async getHeight(args: {} = {}): Promise<{ height: PositiveInteger }> {
+  async getHeight (args: {} = {}): Promise<{ height: PositiveInteger }> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).getHeight(args, this.originator)
   }
 
-  async getHeaderForHeight(args: { height: PositiveInteger }): Promise<{ header: HexString }> {
+  async getHeaderForHeight (args: { height: PositiveInteger }): Promise<{ header: HexString }> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).getHeaderForHeight(args, this.originator)
   }
 
-  async getNetwork(args: {} = {}): Promise<{ network: 'mainnet' | 'testnet' }> {
+  async getNetwork (args: {} = {}): Promise<{ network: 'mainnet' | 'testnet' }> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).getNetwork(args, this.originator)
   }
 
-  async getVersion(args: {} = {}): Promise<{ version: VersionString7To30Bytes }> {
+  async getVersion (args: {} = {}): Promise<{ version: VersionString7To30Bytes }> {
     await this.connectToSubstrate()
     return await (this.substrate as WalletInterface).getVersion(args, this.originator)
   }