@bsv/sdk 1.3.12 → 1.3.14

package/src/wallet/substrates/XDM.ts

@@ -1,7 +1,35 @@
-import { Base64String, BasketStringUnder300Bytes, BEEF, BooleanDefaultFalse, BooleanDefaultTrue, Byte, CertificateFieldNameUnder50Bytes, DescriptionString5to50Bytes, EntityIconURLStringMax500Bytes, EntityNameStringMax100Bytes, HexString, ISOTimestampString, KeyIDStringUnder800Bytes, LabelStringUnder300Bytes, OriginatorDomainNameStringUnder250Bytes, OutpointString, OutputTagStringUnder300Bytes, PositiveInteger, PositiveIntegerDefault10Max10000, PositiveIntegerMax10, PositiveIntegerOrZero, ProtocolString5To400Bytes, PubKeyHex, SatoshiValue, SecurityLevel, TXIDHexString, VersionString7To30Bytes, WalletInterface } from '../Wallet.interfaces.js'
+import {
+  Base64String,
+  BasketStringUnder300Bytes,
+  BEEF,
+  BooleanDefaultFalse,
+  BooleanDefaultTrue,
+  Byte,
+  CertificateFieldNameUnder50Bytes,
+  DescriptionString5to50Bytes,
+  EntityIconURLStringMax500Bytes,
+  EntityNameStringMax100Bytes,
+  HexString,
+  ISOTimestampString,
+  KeyIDStringUnder800Bytes,
+  LabelStringUnder300Bytes,
+  OutpointString,
+  OutputTagStringUnder300Bytes,
+  PositiveInteger,
+  PositiveIntegerDefault10Max10000,
+  PositiveIntegerMax10,
+  PositiveIntegerOrZero,
+  ProtocolString5To400Bytes,
+  PubKeyHex,
+  SatoshiValue,
+  SecurityLevel,
+  TXIDHexString,
+  VersionString7To30Bytes,
+  WalletInterface
+} from '../Wallet.interfaces.js'
 import { Utils, Random } from '../../primitives/index.js'
 import { WalletError } from '../WalletError.js'
-import { CallType } from 'mod.js'
+import { CallType } from '../../../mod.js'
 
 /**
  * Facilitates wallet operations over cross-document messaging.
@@ -14,7 +42,9 @@ export default class XDMSubstrate implements WalletInterface {
       throw new Error('The XDM substrate requires a global window object.')
     }
     if (typeof window.postMessage !== 'function') {
-      throw new Error('The window object does not seem to support postMessage calls.')
+      throw new Error(
+        'The window object does not seem to support postMessage calls.'
+      )
     }
     this.domain = domain
   }
@@ -22,9 +52,16 @@ export default class XDMSubstrate implements WalletInterface {
   async invoke(call: CallType, args: any): Promise<any> {
     return await new Promise((resolve, reject) => {
       const id = Utils.toBase64(Random(12))
-      const listener = async e => {
-        if (e.data.type !== 'CWI' || !e.isTrusted || e.data.id !== id || e.data.isInvocation) return
-        if (typeof window.removeEventListener === 'function') window.removeEventListener('message', listener)
+      const listener = (e: MessageEvent): void => {
+        if (
+          e.data.type !== 'CWI' ||
+          !e.isTrusted ||
+          e.data.id !== id ||
+          e.data.isInvocation === true
+        ) { return }
+        if (typeof window.removeEventListener === 'function') {
+          window.removeEventListener('message', listener)
+        }
         if (e.data.status === 'error') {
           const err = new WalletError(e.data.description, e.data.code)
           reject(err)
@@ -33,101 +70,451 @@ export default class XDMSubstrate implements WalletInterface {
         }
       }
       window.addEventListener('message', listener)
-      window.parent.postMessage({
-        type: 'CWI',
-        isInvocation: true,
-        id,
-        call,
-        args
-      }, this.domain)
+      window.parent.postMessage(
+        {
+          type: 'CWI',
+          isInvocation: true,
+          id,
+          call,
+          args
+        },
+        this.domain
+      )
     })
   }
 
-  async createAction(args: { description: DescriptionString5to50Bytes, inputs?: Array<{ tx?: BEEF, outpoint: OutpointString, unlockingScript?: HexString, unlockingScriptLength?: PositiveInteger, inputDescription: DescriptionString5to50Bytes, sequenceNumber?: PositiveIntegerOrZero }>, outputs?: Array<{ lockingScript: HexString, satoshis: SatoshiValue, outputDescription: DescriptionString5to50Bytes, basket?: BasketStringUnder300Bytes, customInstructions?: string, tags?: OutputTagStringUnder300Bytes[] }>, lockTime?: PositiveIntegerOrZero, version?: PositiveIntegerOrZero, labels?: LabelStringUnder300Bytes[], options?: { signAndProcess?: BooleanDefaultTrue, acceptDelayedBroadcast?: BooleanDefaultTrue, trustSelf?: 'known', knownTxids?: TXIDHexString[], returnTXIDOnly?: BooleanDefaultFalse, noSend?: BooleanDefaultFalse, noSendChange?: OutpointString[], sendWith?: TXIDHexString[] } }): Promise<{ txid?: TXIDHexString, tx?: BEEF, noSendChange?: OutpointString[], sendWithResults?: Array<{ txid: TXIDHexString, status: 'unproven' | 'sending' | 'failed' }>, signableTransaction?: { tx: BEEF, reference: Base64String } }> {
+  async createAction(args: {
+    description: DescriptionString5to50Bytes
+    inputs?: Array<{
+      tx?: BEEF
+      outpoint: OutpointString
+      unlockingScript?: HexString
+      unlockingScriptLength?: PositiveInteger
+      inputDescription: DescriptionString5to50Bytes
+      sequenceNumber?: PositiveIntegerOrZero
+    }>
+    outputs?: Array<{
+      lockingScript: HexString
+      satoshis: SatoshiValue
+      outputDescription: DescriptionString5to50Bytes
+      basket?: BasketStringUnder300Bytes
+      customInstructions?: string
+      tags?: OutputTagStringUnder300Bytes[]
+    }>
+    lockTime?: PositiveIntegerOrZero
+    version?: PositiveIntegerOrZero
+    labels?: LabelStringUnder300Bytes[]
+    options?: {
+      signAndProcess?: BooleanDefaultTrue
+      acceptDelayedBroadcast?: BooleanDefaultTrue
+      trustSelf?: 'known'
+      knownTxids?: TXIDHexString[]
+      returnTXIDOnly?: BooleanDefaultFalse
+      noSend?: BooleanDefaultFalse
+      noSendChange?: OutpointString[]
+      sendWith?: TXIDHexString[]
+    }
+  }): Promise<{
+    txid?: TXIDHexString
+    tx?: BEEF
+    noSendChange?: OutpointString[]
+    sendWithResults?: Array<{
+      txid: TXIDHexString
+      status: 'unproven' | 'sending' | 'failed'
+    }>
+    signableTransaction?: { tx: BEEF, reference: Base64String }
+  }> {
     return await this.invoke('createAction', args)
   }
 
-  async signAction(args: { spends: Record<PositiveIntegerOrZero, { unlockingScript: HexString, sequenceNumber?: PositiveIntegerOrZero }>, reference: Base64String, options?: { acceptDelayedBroadcast?: BooleanDefaultTrue, returnTXIDOnly?: BooleanDefaultFalse, noSend?: BooleanDefaultFalse, noSendChange?: OutpointString[], sendWith: TXIDHexString[] } }): Promise<{ txid?: TXIDHexString, tx?: BEEF, noSendChange?: OutpointString[], sendWithResults?: Array<{ txid: TXIDHexString, status: 'unproven' | 'sending' | 'failed' }> }> {
+  async signAction(args: {
+    spends: Record<
+      PositiveIntegerOrZero,
+      { unlockingScript: HexString, sequenceNumber?: PositiveIntegerOrZero }
+    >
+    reference: Base64String
+    options?: {
+      acceptDelayedBroadcast?: BooleanDefaultTrue
+      returnTXIDOnly?: BooleanDefaultFalse
+      noSend?: BooleanDefaultFalse
+      noSendChange?: OutpointString[]
+      sendWith: TXIDHexString[]
+    }
+  }): Promise<{
+    txid?: TXIDHexString
+    tx?: BEEF
+    noSendChange?: OutpointString[]
+    sendWithResults?: Array<{
+      txid: TXIDHexString
+      status: 'unproven' | 'sending' | 'failed'
+    }>
+  }> {
     return await this.invoke('signAction', args)
   }
 
-  async abortAction(args: { reference: Base64String }): Promise<{ aborted: true }> {
+  async abortAction(args: {
+    reference: Base64String
+  }): Promise<{ aborted: true }> {
     return await this.invoke('abortAction', args)
   }
 
-  async listActions(args: { labels: LabelStringUnder300Bytes[], labelQueryMode?: 'any' | 'all', includeLabels?: BooleanDefaultFalse, includeInputs?: BooleanDefaultFalse, includeInputSourceLockingScripts?: BooleanDefaultFalse, includeInputUnlockingScripts?: BooleanDefaultFalse, includeOutputs?: BooleanDefaultFalse, includeOutputLockingScripts?: BooleanDefaultFalse, limit?: PositiveIntegerDefault10Max10000, offset?: PositiveIntegerOrZero }): Promise<{ totalActions: PositiveIntegerOrZero, actions: Array<{ 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 }>, outputs?: Array<{ outputIndex: PositiveIntegerOrZero, satoshis: SatoshiValue, lockingScript?: HexString, spendable: boolean, outputDescription: DescriptionString5to50Bytes, basket: BasketStringUnder300Bytes, tags: OutputTagStringUnder300Bytes[], customInstructions?: string }> }> }> {
+  async listActions(args: {
+    labels: LabelStringUnder300Bytes[]
+    labelQueryMode?: 'any' | 'all'
+    includeLabels?: BooleanDefaultFalse
+    includeInputs?: BooleanDefaultFalse
+    includeInputSourceLockingScripts?: BooleanDefaultFalse
+    includeInputUnlockingScripts?: BooleanDefaultFalse
+    includeOutputs?: BooleanDefaultFalse
+    includeOutputLockingScripts?: BooleanDefaultFalse
+    limit?: PositiveIntegerDefault10Max10000
+    offset?: PositiveIntegerOrZero
+  }): Promise<{
+    totalActions: PositiveIntegerOrZero
+    actions: Array<{
+      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
+      }>
+      outputs?: Array<{
+        outputIndex: PositiveIntegerOrZero
+        satoshis: SatoshiValue
+        lockingScript?: HexString
+        spendable: boolean
+        outputDescription: DescriptionString5to50Bytes
+        basket: BasketStringUnder300Bytes
+        tags: OutputTagStringUnder300Bytes[]
+        customInstructions?: string
+      }>
+    }>
+  }> {
     return await this.invoke('listActions', args)
   }
 
-  async internalizeAction(args: { tx: BEEF, outputs: Array<{ outputIndex: PositiveIntegerOrZero, protocol: 'wallet payment' | 'basket insertion', paymentRemittance?: { derivationPrefix: Base64String, derivationSuffix: Base64String, senderIdentityKey: PubKeyHex }, insertionRemittance?: { basket: BasketStringUnder300Bytes, customInstructions?: string, tags?: OutputTagStringUnder300Bytes[] } }>, description: DescriptionString5to50Bytes, labels?: LabelStringUnder300Bytes[] }): Promise<{ accepted: true }> {
+  async internalizeAction(args: {
+    tx: BEEF
+    outputs: Array<{
+      outputIndex: PositiveIntegerOrZero
+      protocol: 'wallet payment' | 'basket insertion'
+      paymentRemittance?: {
+        derivationPrefix: Base64String
+        derivationSuffix: Base64String
+        senderIdentityKey: PubKeyHex
+      }
+      insertionRemittance?: {
+        basket: BasketStringUnder300Bytes
+        customInstructions?: string
+        tags?: OutputTagStringUnder300Bytes[]
+      }
+    }>
+    description: DescriptionString5to50Bytes
+    labels?: LabelStringUnder300Bytes[]
+  }): Promise<{ accepted: true }> {
     return await this.invoke('internalizeAction', args)
   }
 
-  async listOutputs(args: { basket: BasketStringUnder300Bytes, tags?: OutputTagStringUnder300Bytes[], tagQueryMode?: 'all' | 'any', include?: 'locking scripts' | 'entire transactions', includeCustomInstructions?: BooleanDefaultFalse, includeTags?: BooleanDefaultFalse, includeLabels?: BooleanDefaultFalse, limit?: PositiveIntegerDefault10Max10000, offset?: PositiveIntegerOrZero }): Promise<{ totalOutputs: PositiveIntegerOrZero, outputs: Array<{ outpoint: OutpointString, satoshis: SatoshiValue, lockingScript?: HexString, tx?: BEEF, spendable: boolean, customInstructions?: string, tags?: OutputTagStringUnder300Bytes[], labels?: LabelStringUnder300Bytes[] }> }> {
+  async listOutputs(args: {
+    basket: BasketStringUnder300Bytes
+    tags?: OutputTagStringUnder300Bytes[]
+    tagQueryMode?: 'all' | 'any'
+    include?: 'locking scripts' | 'entire transactions'
+    includeCustomInstructions?: BooleanDefaultFalse
+    includeTags?: BooleanDefaultFalse
+    includeLabels?: BooleanDefaultFalse
+    limit?: PositiveIntegerDefault10Max10000
+    offset?: PositiveIntegerOrZero
+  }): Promise<{
+    totalOutputs: PositiveIntegerOrZero
+    outputs: Array<{
+      outpoint: OutpointString
+      satoshis: SatoshiValue
+      lockingScript?: HexString
+      tx?: BEEF
+      spendable: boolean
+      customInstructions?: string
+      tags?: OutputTagStringUnder300Bytes[]
+      labels?: LabelStringUnder300Bytes[]
+    }>
+  }> {
     return await this.invoke('listOutputs', args)
   }
 
-  async relinquishOutput(args: { basket: BasketStringUnder300Bytes, output: OutpointString }): Promise<{ relinquished: true }> {
+  async relinquishOutput(args: {
+    basket: BasketStringUnder300Bytes
+    output: OutpointString
+  }): Promise<{ relinquished: true }> {
     return await this.invoke('relinquishOutput', args)
   }
 
-  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 }> {
     return await this.invoke('getPublicKey', args)
   }
 
-  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[]
+  }> {
     return await this.invoke('revealCounterpartyKeyLinkage', args)
   }
 
-  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
+  }> {
     return await this.invoke('revealSpecificKeyLinkage', args)
   }
 
-  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[] }> {
     return await this.invoke('encrypt', args)
   }
 
-  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.invoke('decrypt', args)
   }
 
-  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[] }> {
     return await this.invoke('createHmac', args)
   }
 
-  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 }> {
     return await this.invoke('verifyHmac', args)
   }
 
-  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[] }> {
     return await this.invoke('createSignature', args)
   }
 
-  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 }> {
     return await this.invoke('verifySignature', args)
   }
 
-  async acquireCertificate(args: { type: Base64String, subject: PubKeyHex, serialNumber: Base64String, revocationOutpoint: OutpointString, signature: HexString, fields: Record<CertificateFieldNameUnder50Bytes, string>, certifier: PubKeyHex, keyringRevealer: PubKeyHex | 'certifier', keyringForSubject: Record<CertificateFieldNameUnder50Bytes, Base64String>, acquisitionProtocol: 'direct' | 'issuance', certifierUrl?: string }): Promise<{ type: Base64String, subject: PubKeyHex, serialNumber: Base64String, certifier: PubKeyHex, revocationOutpoint: OutpointString, signature: HexString, fields: Record<CertificateFieldNameUnder50Bytes, string> }> {
+  async acquireCertificate(args: {
+    type: Base64String
+    subject: PubKeyHex
+    serialNumber: Base64String
+    revocationOutpoint: OutpointString
+    signature: HexString
+    fields: Record<CertificateFieldNameUnder50Bytes, string>
+    certifier: PubKeyHex
+    keyringRevealer: PubKeyHex | 'certifier'
+    keyringForSubject: Record<CertificateFieldNameUnder50Bytes, Base64String>
+    acquisitionProtocol: 'direct' | 'issuance'
+    certifierUrl?: string
+  }): Promise<{
+    type: Base64String
+    subject: PubKeyHex
+    serialNumber: Base64String
+    certifier: PubKeyHex
+    revocationOutpoint: OutpointString
+    signature: HexString
+    fields: Record<CertificateFieldNameUnder50Bytes, string>
+  }> {
     return await this.invoke('acquireCertificate', args)
   }
 
-  async listCertificates(args: { certifiers: PubKeyHex[], types: Base64String[], limit?: PositiveIntegerDefault10Max10000, offset?: PositiveIntegerOrZero, privileged?: BooleanDefaultFalse, privilegedReason?: DescriptionString5to50Bytes }): Promise<{ totalCertificates: PositiveIntegerOrZero, certificates: Array<{ type: Base64String, subject: PubKeyHex, serialNumber: Base64String, certifier: PubKeyHex, revocationOutpoint: OutpointString, signature: HexString, fields: Record<CertificateFieldNameUnder50Bytes, string> }> }> {
+  async listCertificates(args: {
+    certifiers: PubKeyHex[]
+    types: Base64String[]
+    limit?: PositiveIntegerDefault10Max10000
+    offset?: PositiveIntegerOrZero
+    privileged?: BooleanDefaultFalse
+    privilegedReason?: DescriptionString5to50Bytes
+  }): Promise<{
+    totalCertificates: PositiveIntegerOrZero
+    certificates: Array<{
+      type: Base64String
+      subject: PubKeyHex
+      serialNumber: Base64String
+      certifier: PubKeyHex
+      revocationOutpoint: OutpointString
+      signature: HexString
+      fields: Record<CertificateFieldNameUnder50Bytes, string>
+    }>
+  }> {
     return await this.invoke('listCertificates', args)
   }
 
-  async proveCertificate(args: { certificate: { type: Base64String, subject: PubKeyHex, serialNumber: Base64String, certifier: PubKeyHex, revocationOutpoint: OutpointString, signature: HexString, fields: Record<CertificateFieldNameUnder50Bytes, string> }, fieldsToReveal: CertificateFieldNameUnder50Bytes[], verifier: PubKeyHex, privileged?: BooleanDefaultFalse, privilegedReason?: DescriptionString5to50Bytes }): Promise<{ keyringForVerifier: Record<CertificateFieldNameUnder50Bytes, Base64String> }> {
+  async proveCertificate(args: {
+    certificate: {
+      type: Base64String
+      subject: PubKeyHex
+      serialNumber: Base64String
+      certifier: PubKeyHex
+      revocationOutpoint: OutpointString
+      signature: HexString
+      fields: Record<CertificateFieldNameUnder50Bytes, string>
+    }
+    fieldsToReveal: CertificateFieldNameUnder50Bytes[]
+    verifier: PubKeyHex
+    privileged?: BooleanDefaultFalse
+    privilegedReason?: DescriptionString5to50Bytes
+  }): Promise<{
+    keyringForVerifier: Record<CertificateFieldNameUnder50Bytes, Base64String>
+  }> {
     return await this.invoke('proveCertificate', args)
   }
 
-  async relinquishCertificate(args: { type: Base64String, serialNumber: Base64String, certifier: PubKeyHex }): Promise<{ relinquished: true }> {
+  async relinquishCertificate(args: {
+    type: Base64String
+    serialNumber: Base64String
+    certifier: PubKeyHex
+  }): Promise<{ relinquished: true }> {
     return await this.invoke('relinquishCertificate', args)
   }
 
-  async discoverByIdentityKey(args: { identityKey: PubKeyHex, limit?: PositiveIntegerDefault10Max10000, offset?: PositiveIntegerOrZero }): Promise<{ totalCertificates: PositiveIntegerOrZero, certificates: Array<{ 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> }> }> {
+  async discoverByIdentityKey(args: {
+    identityKey: PubKeyHex
+    limit?: PositiveIntegerDefault10Max10000
+    offset?: PositiveIntegerOrZero
+  }): Promise<{
+    totalCertificates: PositiveIntegerOrZero
+    certificates: Array<{
+      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>
+    }>
+  }> {
     return await this.invoke('discoverByIdentityKey', args)
   }
 
-  async discoverByAttributes(args: { attributes: Record<CertificateFieldNameUnder50Bytes, string>, limit?: PositiveIntegerDefault10Max10000, offset?: PositiveIntegerOrZero }): Promise<{ totalCertificates: PositiveIntegerOrZero, certificates: Array<{ 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> }> }> {
+  async discoverByAttributes(args: {
+    attributes: Record<CertificateFieldNameUnder50Bytes, string>
+    limit?: PositiveIntegerDefault10Max10000
+    offset?: PositiveIntegerOrZero
+  }): Promise<{
+    totalCertificates: PositiveIntegerOrZero
+    certificates: Array<{
+      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>
+    }>
+  }> {
     return await this.invoke('discoverByAttributes', args)
   }
 
@@ -143,7 +530,9 @@ export default class XDMSubstrate implements WalletInterface {
     return await this.invoke('getHeight', args)
   }
 
-  async getHeaderForHeight(args: { height: PositiveInteger }): Promise<{ header: HexString }> {
+  async getHeaderForHeight(args: {
+    height: PositiveInteger
+  }): Promise<{ header: HexString }> {
     return await this.invoke('getHeaderForHeight', args)
   }