@bsv/sdk 1.3.8 → 1.3.9

package/src/wallet/ProtoWallet.ts

@@ -10,7 +10,6 @@ import {
   GetPublicKeyArgs,
   GetVersionResult,
   OriginatorDomainNameStringUnder250Bytes,
-  ProtoWalletApi,
   PubKeyHex,
   RevealCounterpartyKeyLinkageArgs,
   RevealCounterpartyKeyLinkageResult,
@@ -26,16 +25,14 @@ import {
   WalletEncryptResult
 } from './Wallet.interfaces.js'
 
-const privilegedError = new Error('ProtoWallet is a single-keyring wallet, operating without context about whether its configured keyring is privileged.')
-
 /**
  * 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.
+ * enable the management of identity certificates, or store any data. It is also not concerned with privileged keys.
  */
-export class ProtoWallet implements ProtoWalletApi {
+export class ProtoWallet {
   keyDeriver: KeyDeriverApi
 
   constructor(rootKeyOrKeyDeriver: PrivateKey | 'anyone' | KeyDeriverApi) {
@@ -45,40 +42,9 @@ export class ProtoWallet implements ProtoWalletApi {
     this.keyDeriver = rootKeyOrKeyDeriver as KeyDeriver
   }
 
-  async isAuthenticated(args: {}, Originator?: OriginatorDomainNameStringUnder250Bytes): Promise<AuthenticatedResult> {
-    return { authenticated: true }
-  }
-
-  async waitForAuthentication(args: {}, Originator?: OriginatorDomainNameStringUnder250Bytes): Promise<AuthenticatedResult> {
-    return { authenticated: true }
-  }
-
-  async getNetwork(args: {}, Originator?: OriginatorDomainNameStringUnder250Bytes): Promise<GetNetworkResult> {
-    return { network: 'mainnet' }
-  }
-
-  async getVersion(args: {}, Originator?: OriginatorDomainNameStringUnder250Bytes): Promise<GetVersionResult> {
-    return { version: 'proto-1.0.0' }
-  }
-
-  /**
-   * Convenience method to obtain the identityKey.
-   * @param originator
-   * @returns `await this.getPublicKey({ identityKey: true }, originator)`
-   */
-  async getIdentityKey(
-    originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<{ publicKey: PubKeyHex }> {
-    return await this.getPublicKey({ identityKey: true }, originator)
-  }
-
   async getPublicKey(
-    args: GetPublicKeyArgs,
-    originator?: OriginatorDomainNameStringUnder250Bytes
+    args: GetPublicKeyArgs
   ): Promise<{ publicKey: PubKeyHex }> {
-    if (args.privileged) {
-      throw privilegedError
-    }
     if (args.identityKey) {
       return { publicKey: this.keyDeriver.rootKey.toPublicKey().toString() }
     } else {
@@ -99,12 +65,8 @@ export class ProtoWallet implements ProtoWalletApi {
   }
 
   async revealCounterpartyKeyLinkage(
-    args: RevealCounterpartyKeyLinkageArgs,
-    originator?: OriginatorDomainNameStringUnder250Bytes
+    args: RevealCounterpartyKeyLinkageArgs
   ): Promise<RevealCounterpartyKeyLinkageResult> {
-    if (args.privileged) {
-      throw privilegedError
-    }
     const { publicKey: identityKey } = await this.getPublicKey({ identityKey: true })
     const linkage = this.keyDeriver.revealCounterpartySecret(args.counterparty)
     const linkageProof = new Schnorr().generateProof(this.keyDeriver.rootKey, this.keyDeriver.rootKey.toPublicKey(), PublicKey.fromString(args.counterparty), Point.fromDER(linkage))
@@ -137,12 +99,8 @@ export class ProtoWallet implements ProtoWalletApi {
   }
 
   async revealSpecificKeyLinkage(
-    args: RevealSpecificKeyLinkageArgs,
-    originator?: OriginatorDomainNameStringUnder250Bytes
+    args: RevealSpecificKeyLinkageArgs
   ): Promise<RevealSpecificKeyLinkageResult> {
-    if (args.privileged) {
-      throw privilegedError
-    }
     const { publicKey: identityKey } = await this.getPublicKey({ identityKey: true })
     const linkage = this.keyDeriver.revealSpecificSecret(
       args.counterparty,
@@ -174,12 +132,8 @@ export class ProtoWallet implements ProtoWalletApi {
   }
 
   async encrypt(
-    args: WalletEncryptArgs,
-    originator?: OriginatorDomainNameStringUnder250Bytes
+    args: WalletEncryptArgs
   ): Promise<WalletEncryptResult> {
-    if (args.privileged) {
-      throw privilegedError
-    }
     const key = this.keyDeriver.deriveSymmetricKey(
       args.protocolID,
       args.keyID,
@@ -189,12 +143,8 @@ export class ProtoWallet implements ProtoWalletApi {
   }
 
   async decrypt(
-    args: WalletDecryptArgs,
-    originator?: OriginatorDomainNameStringUnder250Bytes
+    args: WalletDecryptArgs
   ): Promise<WalletDecryptResult> {
-    if (args.privileged) {
-      throw privilegedError
-    }
     const key = this.keyDeriver.deriveSymmetricKey(
       args.protocolID,
       args.keyID,
@@ -204,12 +154,8 @@ export class ProtoWallet implements ProtoWalletApi {
   }
 
   async createHmac(
-    args: CreateHmacArgs,
-    originator?: OriginatorDomainNameStringUnder250Bytes
+    args: CreateHmacArgs
   ): Promise<CreateHmacResult> {
-    if (args.privileged) {
-      throw privilegedError
-    }
     const key = this.keyDeriver.deriveSymmetricKey(
       args.protocolID,
       args.keyID,
@@ -219,12 +165,8 @@ export class ProtoWallet implements ProtoWalletApi {
   }
 
   async verifyHmac(
-    args: VerifyHmacArgs,
-    originator?: OriginatorDomainNameStringUnder250Bytes
+    args: VerifyHmacArgs
   ): Promise<VerifyHmacResult> {
-    if (args.privileged) {
-      throw privilegedError
-    }
     const key = this.keyDeriver.deriveSymmetricKey(
       args.protocolID,
       args.keyID,
@@ -240,12 +182,8 @@ export class ProtoWallet implements ProtoWalletApi {
   }
 
   async createSignature(
-    args: CreateSignatureArgs,
-    originator?: OriginatorDomainNameStringUnder250Bytes
+    args: CreateSignatureArgs
   ): Promise<CreateSignatureResult> {
-    if (args.privileged) {
-      throw privilegedError
-    }
     if (!args.hashToDirectlySign && !args.data) {
       throw new Error('args.data or args.hashToDirectlySign must be valid')
     }
@@ -259,12 +197,8 @@ export class ProtoWallet implements ProtoWalletApi {
   }
 
   async verifySignature(
-    args: VerifySignatureArgs,
-    originator?: OriginatorDomainNameStringUnder250Bytes
+    args: VerifySignatureArgs
   ): Promise<VerifySignatureResult> {
-    if (args.privileged) {
-      throw privilegedError
-    }
     if (!args.hashToDirectlyVerify && !args.data) {
       throw new Error('args.data or args.hashToDirectlyVerify must be valid')
     }

package/src/wallet/Wallet.interfaces.ts

@@ -916,8 +916,10 @@ export interface GetPublicKeyResult {
 }
 
 /**
- * The ProtoWalletApi interface defines a wallet cryptographic capabilities including:
- * key derivation, encryption, decryption, hmac creation and verification, signature generation and verification
+ * The Wallet interface defines a wallet capable of various tasks including transaction creation and signing,
+ * encryption, decryption, identity certificate management, identity verification, and communication
+ * with applications as per the BRC standards. This interface allows applications to interact with
+ * the wallet for a range of functionalities aligned with the Babbage architectural principles.
  *
  * Error Handling
  *
@@ -926,7 +928,7 @@ export interface GetPublicKeyResult {
  * Serialization layers can rely on the `isError` property being unique to error objects to
  * deserialize and rethrow `WalletErrorObject` conforming objects.
  */
-export interface ProtoWalletApi {
+export interface WalletInterface {
   /**
    * Retrieves a derived or identity public key based on the requested protocol, key ID, counterparty, and other factors.
    *
@@ -1035,22 +1037,6 @@ export interface ProtoWalletApi {
     originator?: OriginatorDomainNameStringUnder250Bytes
   ) => Promise<VerifySignatureResult>
 
-}
-
-/**
- * The Wallet interface defines a wallet capable of various tasks including transaction creation and signing,
- * encryption, decryption, identity certificate management, identity verification, and communication
- * with applications as per the BRC standards. This interface allows applications to interact with
- * the wallet for a range of functionalities aligned with the Babbage architectural principles.
- *
- * Error Handling
- *
- * Every method of the `Wallet` interface has a return value of the form `Promise<object>`.
- * When an error occurs, an exception object may be thrown which must conform to the `WalletErrorObject` interface.
- * Serialization layers can rely on the `isError` property being unique to error objects to
- * deserialize and rethrow `WalletErrorObject` conforming objects.
- */
-export interface Wallet extends ProtoWalletApi {
   /**
    * Creates a new Bitcoin transaction based on the provided inputs, outputs, labels, locks, and other options.
    *

package/src/wallet/WalletClient.ts

@@ -1,4 +1,4 @@
-import { AcquireCertificateArgs, AcquireCertificateResult, 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, SecurityLevel, SignActionArgs, SignActionResult, TXIDHexString, VersionString7To30Bytes, Wallet, AuthenticatedResult } from './Wallet.interfaces.js'
+import { AcquireCertificateArgs, AcquireCertificateResult, 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, SecurityLevel, SignActionArgs, SignActionResult, TXIDHexString, VersionString7To30Bytes, WalletInterface, AuthenticatedResult } from './Wallet.interfaces.js'
 import WindowCWISubstrate from './substrates/window.CWI.js'
 import XDMSubstrate from './substrates/XDM.js'
 import WalletWireTransceiver from './substrates/WalletWireTransceiver.js'
@@ -10,10 +10,10 @@ const MAX_XDM_RESPONSE_WAIT = 200
 /**
  * The SDK is how applications communicate with wallets over a communications substrate.
  */
-export default class WalletClient implements Wallet {
-  public substrate: 'auto' | Wallet
+export default class WalletClient implements WalletInterface {
+  public substrate: 'auto' | WalletInterface
   originator?: OriginatorDomainNameStringUnder250Bytes
-  constructor (substrate: 'auto' | 'Cicada' | 'XDM' | 'window.CWI' | 'json-api' | Wallet = '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,11 +22,11 @@ export default class WalletClient implements Wallet {
     this.originator = originator
   }
 
-  async connectToSubstrate () {
+  async connectToSubstrate() {
     if (typeof this.substrate === 'object') {
       return // substrate is already connected
     }
-    let sub: Wallet
+    let sub: WalletInterface
     const checkSub = async (timeout?: number) => {
       let result
       if (typeof timeout === 'number') {
@@ -68,142 +68,142 @@ export default class WalletClient implements Wallet {
     }
   }
 
-  async createAction (args: CreateActionArgs): Promise<CreateActionResult> {
+  async createAction(args: CreateActionArgs): Promise<CreateActionResult> {
     await this.connectToSubstrate()
-    return await (this.substrate as Wallet).createAction(args, this.originator)
+    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 Wallet).signAction(args, this.originator)
+    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 Wallet).abortAction(args, this.originator)
+    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 Wallet).listActions(args, this.originator)
+    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 Wallet).internalizeAction(args, this.originator)
+    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 Wallet).listOutputs(args, this.originator)
+    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 Wallet).relinquishOutput(args, this.originator)
+    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 Wallet).getPublicKey(args, this.originator)
+    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 Wallet).revealCounterpartyKeyLinkage(args, this.originator)
+    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 Wallet).revealSpecificKeyLinkage(args, this.originator)
+    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 Wallet).encrypt(args, this.originator)
+    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[] }> {
-    return await (this.substrate as Wallet).decrypt(args, this.originator)
+  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 Wallet).createHmac(args, this.originator)
+    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 Wallet).verifyHmac(args, this.originator)
+    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 Wallet).createSignature(args, this.originator)
+    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 Wallet).verifySignature(args, this.originator)
+    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 Wallet).acquireCertificate(args, this.originator)
+    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 Wallet).listCertificates(args, this.originator)
+    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 Wallet).proveCertificate(args, this.originator)
+    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 Wallet).relinquishCertificate(args, this.originator)
+    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 Wallet).discoverByIdentityKey(args, this.originator)
+    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 Wallet).discoverByAttributes(args, this.originator)
+    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 Wallet).isAuthenticated(args, this.originator)
+    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 Wallet).waitForAuthentication(args, this.originator)
+    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 Wallet).getHeight(args, this.originator)
+    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 Wallet).getHeaderForHeight(args, this.originator)
+    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 Wallet).getNetwork(args, this.originator)
+    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 Wallet).getVersion(args, this.originator)
+    return await (this.substrate as WalletInterface).getVersion(args, this.originator)
   }
 }

package/src/wallet/__tests/ProtoWallet.test.ts

@@ -7,37 +7,6 @@ describe('ProtoWallet', () => {
   it('Throws when functions are not supported', async () => {
     const wallet = new ProtoWallet('anyone')
   })
-  it('Throws the privileged error when the privileged flag is set', async () => {
-    const wallet = new ProtoWallet('anyone')
-    const privilegedError = 'ProtoWallet is a single-keyring wallet, operating without context about whether its configured keyring is privileged.'
-    await expect(() => {
-      return (wallet as any).encrypt({ privileged: true })
-    }).rejects.toThrow(new Error(privilegedError))
-    await expect(() => {
-      return (wallet as any).decrypt({ privileged: true })
-    }).rejects.toThrow(new Error(privilegedError))
-    await expect(() => {
-      return (wallet as any).createSignature({ privileged: true })
-    }).rejects.toThrow(new Error(privilegedError))
-    await expect(() => {
-      return (wallet as any).verifySignature({ privileged: true })
-    }).rejects.toThrow(new Error(privilegedError))
-    await expect(() => {
-      return (wallet as any).createHmac({ privileged: true })
-    }).rejects.toThrow(new Error(privilegedError))
-    await expect(() => {
-      return (wallet as any).verifyHmac({ privileged: true })
-    }).rejects.toThrow(new Error(privilegedError))
-    await expect(() => {
-      return (wallet as any).getPublicKey({ privileged: true })
-    }).rejects.toThrow(new Error(privilegedError))
-    await expect(() => {
-      return (wallet as any).revealCounterpartyKeyLinkage({ privileged: true })
-    }).rejects.toThrow(new Error(privilegedError))
-    await expect(() => {
-      return (wallet as any).revealSpecificKeyLinkage({ privileged: true })
-    }).rejects.toThrow(new Error(privilegedError))
-  })
   it('Validates the BRC-3 compliance vector', async () => {
     const wallet = new ProtoWallet('anyone')
     const { valid } = await wallet.verifySignature({

package/src/wallet/substrates/HTTPWalletJSON.ts

@@ -1,6 +1,6 @@
-import { Wallet, CreateActionArgs, OriginatorDomainNameStringUnder250Bytes, CreateActionResult, BooleanDefaultTrue, AcquireCertificateArgs, AcquireCertificateResult, Base64String, BasketStringUnder300Bytes, BooleanDefaultFalse, Byte, CertificateFieldNameUnder50Bytes, DescriptionString5to50Bytes, DiscoverCertificatesResult, EntityIconURLStringMax500Bytes, EntityNameStringMax100Bytes, HexString, InternalizeActionArgs, ISOTimestampString, KeyIDStringUnder800Bytes, ListActionsArgs, ListActionsResult, ListCertificatesResult, ListOutputsArgs, ListOutputsResult, OutpointString, PositiveInteger, PositiveIntegerDefault10Max10000, PositiveIntegerMax10, PositiveIntegerOrZero, ProtocolString5To400Bytes, ProveCertificateArgs, ProveCertificateResult, PubKeyHex, SecurityLevel, SignActionArgs, SignActionResult, VersionString7To30Bytes } from '../Wallet.interfaces.js'
+import { WalletInterface, CreateActionArgs, OriginatorDomainNameStringUnder250Bytes, CreateActionResult, BooleanDefaultTrue, AcquireCertificateArgs, AcquireCertificateResult, Base64String, BasketStringUnder300Bytes, BooleanDefaultFalse, Byte, CertificateFieldNameUnder50Bytes, DescriptionString5to50Bytes, DiscoverCertificatesResult, EntityIconURLStringMax500Bytes, EntityNameStringMax100Bytes, HexString, InternalizeActionArgs, ISOTimestampString, KeyIDStringUnder800Bytes, ListActionsArgs, ListActionsResult, ListCertificatesResult, ListOutputsArgs, ListOutputsResult, OutpointString, PositiveInteger, PositiveIntegerDefault10Max10000, PositiveIntegerMax10, PositiveIntegerOrZero, ProtocolString5To400Bytes, ProveCertificateArgs, ProveCertificateResult, PubKeyHex, SecurityLevel, SignActionArgs, SignActionResult, VersionString7To30Bytes } from '../Wallet.interfaces.js'
 
-export default class HTTPWalletJSON implements Wallet {
+export default class HTTPWalletJSON implements WalletInterface {
   baseUrl: string
   httpClient: typeof fetch
   originator: OriginatorDomainNameStringUnder250Bytes | undefined
@@ -23,7 +23,7 @@ export default class HTTPWalletJSON implements Wallet {
         })).json()
         return response
       } catch (error) {
-        console.log({ 'HTTPWalletJSON': { call, args, error }})
+        console.log({ 'HTTPWalletJSON': { call, args, error } })
         throw error
       }
     }

package/src/wallet/substrates/WalletWireProcessor.ts

@@ -1,4 +1,4 @@
-import { Wallet } from '../Wallet.interfaces.js'
+import { WalletInterface } from '../Wallet.interfaces.js'
 import WalletWire from './WalletWire.js'
 import { Utils } from '../../primitives/index.js'
 import calls from './WalletWireCalls.js'
@@ -9,9 +9,9 @@ import { SecurityLevel } from '../Wallet.interfaces.js'
  * Processes incoming wallet calls received over a wallet wire, with a given wallet.
  */
 export default class WalletWireProcessor implements WalletWire {
-  wallet: Wallet
+  wallet: WalletInterface
 
-  constructor(wallet: Wallet) {
+  constructor(wallet: WalletInterface) {
     this.wallet = wallet
   }
 

package/src/wallet/substrates/WalletWireTransceiver.ts

@@ -1,4 +1,4 @@
-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, Wallet } from '../Wallet.interfaces.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.js'
 import WalletWire from './WalletWire.js'
 import { Certificate } from '../../auth/index.js'
 import { Utils } from '../../primitives/index.js'
@@ -8,7 +8,7 @@ import { WalletError } from '../WalletError.js'
 /**
  * A way to make remote calls to a wallet over a wallet wire.
  */
-export default class WalletWireTransceiver implements Wallet {
+export default class WalletWireTransceiver implements WalletInterface {
   wire: WalletWire
 
   constructor(wire: WalletWire) {

package/src/wallet/substrates/XDM.ts

@@ -1,4 +1,4 @@
-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, Wallet } from '../Wallet.interfaces.js'
+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 { Utils, Random } from '../../primitives/index.js'
 import { WalletError } from '../WalletError.js'
 import { CallType } from 'mod.js'
@@ -6,9 +6,9 @@ import { CallType } from 'mod.js'
 /**
  * Facilitates wallet operations over cross-document messaging.
  */
-export default class XDMSubstrate implements Wallet {
+export default class XDMSubstrate implements WalletInterface {
   private readonly domain: string
-  
+
   constructor(domain: string = '*') {
     if (typeof window !== 'object') {
       throw new Error('The XDM substrate requires a global window object.')