@bsv/sdk 1.3.2 → 1.3.4

package/src/wallet/ProtoWallet.ts

@@ -1,277 +1,90 @@
+import { KeyDeriver, KeyDeriverApi } from './KeyDeriver.js'
+import { Hash, ECDSA, BigNumber, Signature, Schnorr, PublicKey, Point, PrivateKey } from '../primitives/index.js'
 import {
-  Base64String,
-  BasketStringUnder300Bytes,
-  BEEF,
-  BooleanDefaultFalse,
-  BooleanDefaultTrue,
-  Byte,
-  CertificateFieldNameUnder50Bytes,
-  DescriptionString5to50Bytes,
-  EntityIconURLStringMax500Bytes,
-  EntityNameStringMax100Bytes,
-  HexString,
-  ISOTimestampString,
-  KeyIDStringUnder800Bytes,
-  LabelStringUnder300Bytes,
+  AuthenticatedResult,
+  CreateHmacArgs,
+  CreateHmacResult,
+  CreateSignatureArgs,
+  CreateSignatureResult,
+  GetNetworkResult,
+  GetPublicKeyArgs,
+  GetVersionResult,
   OriginatorDomainNameStringUnder250Bytes,
-  OutpointString,
-  OutputTagStringUnder300Bytes,
-  PositiveInteger,
-  PositiveIntegerDefault10Max10000,
-  PositiveIntegerMax10,
-  PositiveIntegerOrZero,
-  ProtocolString5To400Bytes,
+  ProtoWalletApi,
   PubKeyHex,
-  SatoshiValue,
-  SecurityLevel,
-  TXIDHexString,
-  VersionString7To30Bytes,
-  Wallet
+  RevealCounterpartyKeyLinkageArgs,
+  RevealCounterpartyKeyLinkageResult,
+  RevealSpecificKeyLinkageArgs,
+  RevealSpecificKeyLinkageResult,
+  VerifyHmacArgs,
+  VerifyHmacResult,
+  VerifySignatureArgs,
+  VerifySignatureResult,
+  WalletDecryptArgs,
+  WalletDecryptResult,
+  WalletEncryptArgs,
+  WalletEncryptResult
 } from './Wallet.interfaces.js'
-import KeyDeriver from './KeyDeriver.js'
-import { PrivateKey, Hash, ECDSA, BigNumber, Signature, Schnorr, PublicKey, Point } from '../primitives/index.js'
-import walletErrors, { WalletError } from './WalletError.js'
+
+const privilegedError = new Error('ProtoWallet is a single-keyring wallet, operating without context about whether its configured keyring is privileged.')
 
 /**
- * A ProtoWallet is a structure that fulfills the Wallet interface, capable of performing all foundational cryptographic operations. It can derive keys, create signatures, facilitate encryption and HMAC operations, and reveal key linkages. However, ProtoWallet does not create transactions, manage outputs, interact with the blockchain, enable the management of identity certificates, or store any data.
+ * A ProtoWallet is precursor to a full wallet, capable of performing all foundational cryptographic operations.
+ * It can derive keys, create signatures, facilitate encryption and HMAC operations, and reveal key linkages.
+ * 
+ * However, ProtoWallet does not create transactions, manage outputs, interact with the blockchain,
+ * enable the management of identity certificates, or store any data.
  */
-export default class ProtoWallet implements Wallet {
-  keyDeriver: KeyDeriver
-  privilegedError: string =
-    'ProtoWallet is a single-keyring wallet, operating without context about whether its configured keyring is privileged.'
-
-  constructor (rootKey: PrivateKey | 'anyone', KeyDeriverClass = KeyDeriver) {
-    this.keyDeriver = new KeyDeriverClass(rootKey)
-  }
-
-  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[]
-        randomizeOutputs?: BooleanDefaultTrue
-      }
-    },
-    originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<{
-      txid?: TXIDHexString
-      tx?: BEEF
-      noSendChange?: OutpointString[]
-      sendWithResults?: Array<{
-        txid: TXIDHexString
-        status: 'unproven' | 'sending' | 'failed'
-      }>
-      signableTransaction?: {
-        tx: BEEF
-        reference: Base64String
-      }
-    }> {
-    throw new WalletError('ProtoWallet does not support creating transactions.', walletErrors.unsupportedAction)
-  }
+export class ProtoWallet implements ProtoWalletApi {
+  keyDeriver: KeyDeriverApi
 
-  async signAction (
-    args: {
-      spends: Record<
-      PositiveIntegerOrZero,
-      {
-        unlockingScript: HexString
-        sequenceNumber?: PositiveIntegerOrZero
-      }
-      >
-      reference: Base64String
-      options?: {
-        acceptDelayedBroadcast?: BooleanDefaultTrue
-        returnTXIDOnly?: BooleanDefaultFalse
-        noSend?: BooleanDefaultFalse
-        noSendChange?: OutpointString[]
-        sendWith?: TXIDHexString[]
-      }
-    },
-    originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<{
-      txid?: TXIDHexString
-      tx?: BEEF
-      noSendChange?: OutpointString[]
-      sendWithResults?: Array<{
-        txid: TXIDHexString
-        status: 'unproven' | 'sending' | 'failed'
-      }>
-    }> {
-    throw new WalletError('ProtoWallet does not support creating transactions.', walletErrors.unsupportedAction)
+  constructor(rootKeyOrKeyDeriver: PrivateKey | 'anyone' | KeyDeriverApi) {
+    if (typeof rootKeyOrKeyDeriver['identityKey'] !== 'string') {
+      rootKeyOrKeyDeriver = new KeyDeriver(rootKeyOrKeyDeriver as PrivateKey | 'anyone')
+    }
+    this.keyDeriver = rootKeyOrKeyDeriver as KeyDeriver
   }
 
-  async abortAction (
-    args: {
-      reference: Base64String
-    },
-    originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<{ aborted: true }> {
-    throw new WalletError('ProtoWallet does not support aborting transactions.', walletErrors.unsupportedAction)
+  async isAuthenticated(args: {}, Originator?: OriginatorDomainNameStringUnder250Bytes): Promise<AuthenticatedResult> {
+    return { authenticated: true }
   }
 
-  async listActions (
-    args: {
-      labels: LabelStringUnder300Bytes[]
-      labelQueryMode?: 'any' | 'all'
-      includeLabels?: BooleanDefaultFalse
-      includeInputs?: BooleanDefaultFalse
-      includeInputSourceLockingScripts?: BooleanDefaultFalse
-      includeInputUnlockingScripts?: BooleanDefaultFalse
-      includeOutputs?: BooleanDefaultFalse
-      includeOutputLockingScripts?: BooleanDefaultFalse
-      limit?: PositiveIntegerDefault10Max10000
-      offset?: PositiveIntegerOrZero
-    },
-    originator?: OriginatorDomainNameStringUnder250Bytes
-  ): 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
-        }>
-      }>
-    }> {
-    throw new WalletError('ProtoWallet does not support retrieving transactions.', walletErrors.unsupportedAction)
+  async waitForAuthentication(args: {}, Originator?: OriginatorDomainNameStringUnder250Bytes): Promise<AuthenticatedResult> {
+    return { authenticated: 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[]
-    },
-    originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<{ accepted: true }> {
-    throw new WalletError('ProtoWallet does not support internalizing transactions.', walletErrors.unsupportedAction)
+  async getNetwork(args: {}, Originator?: OriginatorDomainNameStringUnder250Bytes): Promise<GetNetworkResult> {
+    return { network: 'mainnet' }
   }
 
-  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
-    },
-    originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<{
-      totalOutputs: PositiveIntegerOrZero
-      outputs: Array<{
-        outpoint: OutpointString
-        satoshis: SatoshiValue
-        lockingScript?: HexString
-        tx?: BEEF
-        spendable: true
-        customInstructions?: string
-        tags?: OutputTagStringUnder300Bytes[]
-        labels?: LabelStringUnder300Bytes[]
-      }>
-    }> {
-    throw new WalletError('ProtoWallet does not support retrieving outputs.', walletErrors.unsupportedAction)
+  async getVersion(args: {}, Originator?: OriginatorDomainNameStringUnder250Bytes): Promise<GetVersionResult> {
+    return { version: 'proto-1.0.0' }
   }
 
-  async relinquishOutput (
-    args: {
-      basket: BasketStringUnder300Bytes
-      output: OutpointString
-    },
+  /**
+   * Convenience method to obtain the identityKey.
+   * @param originator 
+   * @returns `await this.getPublicKey({ identityKey: true }, originator)`
+   */
+  async getIdentityKey(
     originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<{ relinquished: true }> {
-    throw new WalletError('ProtoWallet does not support deleting outputs.', walletErrors.unsupportedAction)
+  ): Promise<{ publicKey: PubKeyHex }> {
+    return await this.getPublicKey({ identityKey: true }, originator)
   }
 
-  async getPublicKey (
-    args: {
-      identityKey?: true
-      protocolID?: [SecurityLevel, ProtocolString5To400Bytes]
-      keyID?: KeyIDStringUnder800Bytes
-      privileged?: BooleanDefaultFalse
-      privilegedReason?: DescriptionString5to50Bytes
-      counterparty?: PubKeyHex | 'self' | 'anyone'
-      forSelf?: BooleanDefaultFalse
-    },
+  async getPublicKey(
+    args: GetPublicKeyArgs,
     originator?: OriginatorDomainNameStringUnder250Bytes
   ): Promise<{ publicKey: PubKeyHex }> {
     if (args.privileged) {
-      throw new WalletError(this.privilegedError)
+      throw privilegedError
     }
     if (args.identityKey) {
       return { publicKey: this.keyDeriver.rootKey.toPublicKey().toString() }
     } else {
+      if (!args.protocolID || !args.keyID) {
+        throw new Error('protocolID and keyID are required if identityKey is false or undefined.')
+      }
       return {
         publicKey: this.keyDeriver
           .derivePublicKey(
@@ -285,24 +98,12 @@ export default class ProtoWallet implements Wallet {
     }
   }
 
-  async revealCounterpartyKeyLinkage (
-    args: {
-      counterparty: PubKeyHex
-      verifier: PubKeyHex
-      privilegedReason?: DescriptionString5to50Bytes
-      privileged?: BooleanDefaultFalse
-    },
+  async revealCounterpartyKeyLinkage(
+    args: RevealCounterpartyKeyLinkageArgs,
     originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<{
-      prover: PubKeyHex
-      verifier: PubKeyHex
-      counterparty: PubKeyHex
-      revelationTime: ISOTimestampString
-      encryptedLinkage: Byte[]
-      encryptedLinkageProof: Byte[]
-    }> {
+  ): Promise<RevealCounterpartyKeyLinkageResult> {
     if (args.privileged) {
-      throw new WalletError(this.privilegedError)
+      throw privilegedError
     }
     const { publicKey: identityKey } = await this.getPublicKey({ identityKey: true })
     const linkage = this.keyDeriver.revealCounterpartySecret(args.counterparty)
@@ -335,28 +136,12 @@ export default class ProtoWallet implements Wallet {
     }
   }
 
-  async revealSpecificKeyLinkage (
-    args: {
-      counterparty: PubKeyHex
-      verifier: PubKeyHex
-      protocolID: [SecurityLevel, ProtocolString5To400Bytes]
-      keyID: KeyIDStringUnder800Bytes
-      privilegedReason?: DescriptionString5to50Bytes
-      privileged?: BooleanDefaultFalse
-    },
+  async revealSpecificKeyLinkage(
+    args: RevealSpecificKeyLinkageArgs,
     originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<{
-      prover: PubKeyHex
-      verifier: PubKeyHex
-      counterparty: PubKeyHex
-      protocolID: [SecurityLevel, ProtocolString5To400Bytes]
-      keyID: KeyIDStringUnder800Bytes
-      encryptedLinkage: Byte[]
-      encryptedLinkageProof: Byte[]
-      proofType: Byte
-    }> {
+  ): Promise<RevealSpecificKeyLinkageResult> {
     if (args.privileged) {
-      throw new WalletError(this.privilegedError)
+      throw privilegedError
     }
     const { publicKey: identityKey } = await this.getPublicKey({ identityKey: true })
     const linkage = this.keyDeriver.revealSpecificSecret(
@@ -388,19 +173,12 @@ export default class ProtoWallet implements Wallet {
     }
   }
 
-  async encrypt (
-    args: {
-      plaintext: Byte[]
-      protocolID: [SecurityLevel, ProtocolString5To400Bytes]
-      keyID: KeyIDStringUnder800Bytes
-      privilegedReason?: DescriptionString5to50Bytes
-      counterparty?: PubKeyHex | 'self' | 'anyone'
-      privileged?: BooleanDefaultFalse
-    },
+  async encrypt(
+    args: WalletEncryptArgs,
     originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<{ ciphertext: Byte[] }> {
+  ): Promise<WalletEncryptResult> {
     if (args.privileged) {
-      throw new WalletError(this.privilegedError)
+      throw privilegedError
     }
     const key = this.keyDeriver.deriveSymmetricKey(
       args.protocolID,
@@ -410,19 +188,12 @@ export default class ProtoWallet implements Wallet {
     return { ciphertext: key.encrypt(args.plaintext) as number[] }
   }
 
-  async decrypt (
-    args: {
-      ciphertext: Byte[]
-      protocolID: [SecurityLevel, ProtocolString5To400Bytes]
-      keyID: KeyIDStringUnder800Bytes
-      privilegedReason?: DescriptionString5to50Bytes
-      counterparty?: PubKeyHex | 'self' | 'anyone'
-      privileged?: BooleanDefaultFalse
-    },
+  async decrypt(
+    args: WalletDecryptArgs,
     originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<{ plaintext: Byte[] }> {
+  ): Promise<WalletDecryptResult> {
     if (args.privileged) {
-      throw new WalletError(this.privilegedError)
+      throw privilegedError
     }
     const key = this.keyDeriver.deriveSymmetricKey(
       args.protocolID,
@@ -432,19 +203,12 @@ export default class ProtoWallet implements Wallet {
     return { plaintext: key.decrypt(args.ciphertext) as number[] }
   }
 
-  async createHmac (
-    args: {
-      data: Byte[]
-      protocolID: [SecurityLevel, ProtocolString5To400Bytes]
-      keyID: KeyIDStringUnder800Bytes
-      privilegedReason?: DescriptionString5to50Bytes
-      counterparty?: PubKeyHex | 'self' | 'anyone'
-      privileged?: BooleanDefaultFalse
-    },
+  async createHmac(
+    args: CreateHmacArgs,
     originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<{ hmac: Byte[] }> {
+  ): Promise<CreateHmacResult> {
     if (args.privileged) {
-      throw new WalletError(this.privilegedError)
+      throw privilegedError
     }
     const key = this.keyDeriver.deriveSymmetricKey(
       args.protocolID,
@@ -454,20 +218,12 @@ export default class ProtoWallet implements Wallet {
     return { hmac: Hash.sha256hmac(key.toArray(), args.data) }
   }
 
-  async verifyHmac (
-    args: {
-      data: Byte[]
-      hmac: Byte[]
-      protocolID: [SecurityLevel, ProtocolString5To400Bytes]
-      keyID: KeyIDStringUnder800Bytes
-      privilegedReason?: DescriptionString5to50Bytes
-      counterparty?: PubKeyHex | 'self' | 'anyone'
-      privileged?: BooleanDefaultFalse
-    },
+  async verifyHmac(
+    args: VerifyHmacArgs,
     originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<{ valid: true }> {
+  ): Promise<VerifyHmacResult> {
     if (args.privileged) {
-      throw new WalletError(this.privilegedError)
+      throw privilegedError
     }
     const key = this.keyDeriver.deriveSymmetricKey(
       args.protocolID,
@@ -476,30 +232,24 @@ export default class ProtoWallet implements Wallet {
     )
     const valid = Hash.sha256hmac(key.toArray(), args.data).toString() === args.hmac.toString()
     if (!valid) {
-      throw new WalletError('HMAC is not valid', walletErrors.invalidHmac)
+      const e = new Error('HMAC is not valid');
+      (e as any).code = 'ERR_INVALID_HMAC'
+      throw e
     }
     return { valid }
   }
 
-  async createSignature (
-    args: {
-      data?: Byte[]
-      hashToDirectlySign?: Byte[]
-      protocolID: [SecurityLevel, ProtocolString5To400Bytes]
-      keyID: KeyIDStringUnder800Bytes
-      privilegedReason?: DescriptionString5to50Bytes
-      counterparty?: PubKeyHex | 'self' | 'anyone'
-      privileged?: BooleanDefaultFalse
-    },
+  async createSignature(
+    args: CreateSignatureArgs,
     originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<{ signature: Byte[] }> {
+  ): Promise<CreateSignatureResult> {
     if (args.privileged) {
-      throw new WalletError(this.privilegedError)
+      throw privilegedError
     }
-    let hash: number[] = args.hashToDirectlySign
-    if (!hash) {
-      hash = Hash.sha256(args.data)
+    if (!args.hashToDirectlySign && !args.data) {
+      throw new Error('args.data or args.hashToDirectlySign must be valid')
     }
+    const hash: number[] = args.hashToDirectlySign || Hash.sha256(args.data!)
     const key = this.keyDeriver.derivePrivateKey(
       args.protocolID,
       args.keyID,
@@ -508,27 +258,17 @@ export default class ProtoWallet implements Wallet {
     return { signature: ECDSA.sign(new BigNumber(hash), key, true).toDER() as number[] }
   }
 
-  async verifySignature (
-    args: {
-      data?: Byte[]
-      hashToDirectlyVerify?: Byte[]
-      signature: Byte[]
-      protocolID: [SecurityLevel, ProtocolString5To400Bytes]
-      keyID: KeyIDStringUnder800Bytes
-      privilegedReason?: DescriptionString5to50Bytes
-      counterparty?: PubKeyHex | 'self' | 'anyone'
-      forSelf?: BooleanDefaultFalse
-      privileged?: BooleanDefaultFalse
-    },
+  async verifySignature(
+    args: VerifySignatureArgs,
     originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<{ valid: true }> {
+  ): Promise<VerifySignatureResult> {
     if (args.privileged) {
-      throw new WalletError(this.privilegedError)
+      throw privilegedError
     }
-    let hash: number[] = args.hashToDirectlyVerify
-    if (!hash) {
-      hash = Hash.sha256(args.data)
+    if (!args.hashToDirectlyVerify && !args.data) {
+      throw new Error('args.data or args.hashToDirectlyVerify must be valid')
     }
+    const hash: number[] = args.hashToDirectlyVerify || Hash.sha256(args.data!)
     const key = this.keyDeriver.derivePublicKey(
       args.protocolID,
       args.keyID,
@@ -537,197 +277,12 @@ export default class ProtoWallet implements Wallet {
     )
     const valid = ECDSA.verify(new BigNumber(hash), Signature.fromDER(args.signature), key)
     if (!valid) {
-      throw new WalletError('Signature is not valid', walletErrors.invalidSignature)
+      const e = new Error('Signature is not valid');
+      (e as any).code = 'ERR_INVALID_SIGNATURE'
+      throw e
     }
     return { valid }
   }
-
-  async acquireCertificate (
-    args: {
-      type: Base64String
-      certifier: PubKeyHex
-      acquisitionProtocol: 'direct' | 'issuance'
-      fields: Record<CertificateFieldNameUnder50Bytes, string>
-      serialNumber?: Base64String
-      revocationOutpoint?: OutpointString
-      signature?: HexString
-      certifierUrl?: string
-      keyringRevealer?: PubKeyHex | 'certifier'
-      keyringForSubject?: Record<CertificateFieldNameUnder50Bytes, Base64String>
-      privileged?: BooleanDefaultFalse
-      privilegedReason?: DescriptionString5to50Bytes
-    },
-    originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<{
-      type: Base64String
-      subject: PubKeyHex
-      serialNumber: Base64String
-      certifier: PubKeyHex
-      revocationOutpoint: OutpointString
-      signature: HexString
-      fields: Record<CertificateFieldNameUnder50Bytes, string>
-    }> {
-    throw new WalletError('ProtoWallet does not support acquiring certificates.', walletErrors.unsupportedAction)
-  }
-
-  async listCertificates (
-    args: {
-      certifiers: PubKeyHex[]
-      types: Base64String[]
-      limit?: PositiveIntegerDefault10Max10000
-      offset?: PositiveIntegerOrZero
-      privileged?: BooleanDefaultFalse
-      privilegedReason?: DescriptionString5to50Bytes
-    },
-    originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<{
-      totalCertificates: PositiveIntegerOrZero
-      certificates: Array<{
-        type: Base64String
-        subject: PubKeyHex
-        serialNumber: Base64String
-        certifier: PubKeyHex
-        revocationOutpoint: OutpointString
-        signature: HexString
-        fields: Record<CertificateFieldNameUnder50Bytes, string>
-      }>
-    }> {
-    throw new WalletError('ProtoWallet does not support retrieving certificates.', walletErrors.unsupportedAction)
-  }
-
-  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
-    },
-    originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<{
-      keyringForVerifier: Record<CertificateFieldNameUnder50Bytes, Base64String>
-    }> {
-    throw new WalletError('ProtoWallet does not support proving certificates.', walletErrors.unsupportedAction)
-  }
-
-  async relinquishCertificate (
-    args: {
-      type: Base64String
-      serialNumber: Base64String
-      certifier: PubKeyHex
-    },
-    originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<{ relinquished: true }> {
-    throw new WalletError('ProtoWallet does not support deleting certificates.', walletErrors.unsupportedAction)
-  }
-
-  async discoverByIdentityKey (
-    args: {
-      identityKey: PubKeyHex
-      limit?: PositiveIntegerDefault10Max10000
-      offset?: PositiveIntegerOrZero
-    },
-    originator?: OriginatorDomainNameStringUnder250Bytes
-  ): 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>
-      }>
-    }> {
-    throw new WalletError('ProtoWallet does not support resolving identities.', walletErrors.unsupportedAction)
-  }
-
-  async discoverByAttributes (
-    args: {
-      attributes: Record<CertificateFieldNameUnder50Bytes, string>
-      limit?: PositiveIntegerDefault10Max10000
-      offset?: PositiveIntegerOrZero
-    },
-    originator?: OriginatorDomainNameStringUnder250Bytes
-  ): 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>
-      }>
-    }> {
-    throw new WalletError('ProtoWallet does not support resolving identities.', walletErrors.unsupportedAction)
-  }
-
-  async isAuthenticated (
-    args: {},
-    originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<{ authenticated: boolean }> {
-    return { authenticated: true }
-  }
-
-  async waitForAuthentication (
-    args: {},
-    originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<{ authenticated: true }> {
-    return { authenticated: true }
-  }
-
-  async getHeight (
-    args: {},
-    originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<{ height: PositiveInteger }> {
-    throw new WalletError('ProtoWallet does not support blockchain tracking.', walletErrors.unsupportedAction)
-  }
-
-  async getHeaderForHeight (
-    args: { height: PositiveInteger },
-    originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<{ header: HexString }> {
-    throw new WalletError('ProtoWallet does not support blockchain tracking.', walletErrors.unsupportedAction)
-  }
-
-  async getNetwork (
-    args: {},
-    originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<{ network: 'mainnet' | 'testnet' }> {
-    return { network: 'mainnet' }
-  }
-
-  async getVersion (
-    args: {},
-    originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<{ version: VersionString7To30Bytes }> {
-    return { version: 'proto-1.0.0' }
-  }
 }
+
+export default ProtoWallet