@bsv/sdk 1.3.8 → 1.3.10

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()
@@ -26,7 +26,7 @@ export default class WalletClient implements Wallet {
     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') {
@@ -70,140 +70,140 @@ export default class WalletClient implements Wallet {
 
   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> {
     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 }> {
     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> {
     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 }> {
     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> {
     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 }> {
     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 }> {
     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[] }> {
     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 }> {
     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[] }> {
     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)
+    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[] }> {
     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 }> {
     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[] }> {
     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 }> {
     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> {
     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> {
     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> {
     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 }> {
     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> {
     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> {
     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> {
     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 }> {
     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 }> {
     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 }> {
     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' }> {
     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 }> {
     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.')

package/src/wallet/substrates/__tests/WalletWire.integration.test.ts

@@ -60,47 +60,6 @@ describe('WalletWire Integration Tests', () => {
         return (wallet as any).discoverByAttributes()
       }).rejects.toThrow()
     })
-    it('Throws the privileged error when the privileged flag is set', async () => {
-      const wallet = new WalletWireTransceiver(new WalletWireProcessor(new ProtoWallet('anyone')))
-      const privilegedError = 'ProtoWallet is a single-keyring wallet, operating without context about whether its configured keyring is privileged.'
-      const saneParams = {
-        protocolID: [0, 'hello world'],
-        keyID: '123123123',
-        plaintext: [0, 1, 3],
-        ciphertext: [3, 4, 5],
-        data: [1, 3, 5],
-        hmac: [1, 3, 5],
-        signature: [1, 3, 5],
-        counterparty: 'self'
-      }
-      await expect(() => {
-        return (wallet as any).encrypt({ ...saneParams, privileged: true })
-      }).rejects.toThrow(new Error(privilegedError))
-      await expect(() => {
-        return (wallet as any).decrypt({ ...saneParams, privileged: true })
-      }).rejects.toThrow(new Error(privilegedError))
-      await expect(() => {
-        return (wallet as any).createSignature({ ...saneParams, privileged: true })
-      }).rejects.toThrow(new Error(privilegedError))
-      await expect(() => {
-        return (wallet as any).verifySignature({ ...saneParams, privileged: true })
-      }).rejects.toThrow(new Error(privilegedError))
-      await expect(() => {
-        return (wallet as any).createHmac({ ...saneParams, privileged: true })
-      }).rejects.toThrow(new Error(privilegedError))
-      await expect(() => {
-        return (wallet as any).verifyHmac({ ...saneParams, privileged: true })
-      }).rejects.toThrow(new Error(privilegedError))
-      await expect(() => {
-        return (wallet as any).getPublicKey({ ...saneParams, privileged: true })
-      }).rejects.toThrow(new Error(privilegedError))
-      await expect(() => {
-        return (wallet as any).revealCounterpartyKeyLinkage({ ...saneParams, privileged: true })
-      }).rejects.toThrow(new Error(privilegedError))
-      await expect(() => {
-        return (wallet as any).revealSpecificKeyLinkage({ ...saneParams, privileged: true })
-      }).rejects.toThrow(new Error(privilegedError))
-    })
     it('Validates the BRC-3 compliance vector', async () => {
       const wallet = new WalletWireTransceiver(new WalletWireProcessor(new ProtoWallet('anyone')))
       const { valid } = await wallet.verifySignature({
@@ -356,13 +315,6 @@ describe('WalletWire Integration Tests', () => {
         counterparty: counterpartyKey.toPublicKey().toString()
       })).rejects.toThrow()
     })
-    it('Returns the expected version, network, and authentication status', async () => {
-      const wallet = new WalletWireTransceiver(new WalletWireProcessor(new ProtoWallet('anyone')))
-      expect(await wallet.getVersion({})).toEqual({ version: 'proto-1.0.0' })
-      expect(await wallet.getNetwork({})).toEqual({ network: 'mainnet' })
-      expect(await wallet.isAuthenticated({})).toEqual({ authenticated: true })
-      expect(await wallet.waitForAuthentication({})).toEqual({ authenticated: true })
-    })
     it('Uses anyone for creating signatures and self for other operations if no counterparty is provided', async () => {
       const userKey = PrivateKey.fromRandom()
       const user = new WalletWireTransceiver(new WalletWireProcessor(new ProtoWallet(userKey)))
@@ -1132,16 +1084,6 @@ describe('WalletWire Integration Tests', () => {
       expect(typeof result.publicKey).toBe('string')
       expect(result.publicKey.length).toBe(66)
     })
-
-    it('should throw an error for privileged operation without permission', async () => {
-      const wallet = createTestWalletWire(new ProtoWallet(PrivateKey.fromRandom()))
-      const args = {
-        identityKey: true as true,
-        privileged: true,
-        privilegedReason: 'Test privileged operation'
-      }
-      await expect(wallet.getPublicKey(args)).rejects.toThrow()
-    })
   })
 
   describe('encrypt and decrypt', () => {
@@ -1304,54 +1246,8 @@ describe('WalletWire Integration Tests', () => {
       const expectedLinkage = proverKey.deriveSharedSecret(counterpartyKey.toPublicKey()).encode(true)
       expect(decryptedResult.plaintext).toEqual(expectedLinkage)
     })
-
-    it('should throw an error when trying to reveal linkage without privilege', async () => {
-      const proverKey = PrivateKey.fromRandom()
-      const counterpartyKey = PrivateKey.fromRandom()
-      const verifierKey = PrivateKey.fromRandom()
-
-      const proverWallet = createTestWalletWire(new ProtoWallet(proverKey))
-
-      const args = {
-        counterparty: counterpartyKey.toPublicKey().toString(),
-        verifier: verifierKey.toPublicKey().toString(),
-        privileged: true
-      }
-
-      await expect(proverWallet.revealCounterpartyKeyLinkage(args)).rejects.toThrow()
-    })
-  })
-
-  describe('getVersion and getNetwork', () => {
-    it('should return the correct version', async () => {
-      const wallet = createTestWalletWire(new ProtoWallet('anyone'))
-      const result = await wallet.getVersion({})
-      expect(result).toHaveProperty('version')
-      expect(typeof result.version).toBe('string')
-    })
-
-    it('should return the correct network', async () => {
-      const wallet = createTestWalletWire(new ProtoWallet('anyone'))
-      const result = await wallet.getNetwork({})
-      expect(result).toHaveProperty('network')
-      expect(['mainnet', 'testnet']).toContain(result.network)
-    })
   })
 
-  describe('isAuthenticated and waitForAuthentication', () => {
-    it('should return authentication status', async () => {
-      const wallet = createTestWalletWire(new ProtoWallet('anyone'))
-      const result = await wallet.isAuthenticated({})
-      expect(result).toHaveProperty('authenticated')
-      expect(typeof result.authenticated).toBe('boolean')
-    })
-
-    it('should wait for authentication', async () => {
-      const wallet = createTestWalletWire(new ProtoWallet('anyone'))
-      const result = await wallet.waitForAuthentication({})
-      expect(result).toEqual({ authenticated: true })
-    })
-  })
   describe('acquireCertificate', () => {
     it('should acquire a certificate with valid inputs', async () => {
       // Mock the acquireCertificate method

package/src/wallet/substrates/window.CWI.ts

@@ -1,14 +1,14 @@
-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'
 
 declare const window: {
-  CWI?: Wallet
+  CWI?: WalletInterface
 } & Window
 
 /**
  * Facilitates wallet operations over the window.CWI interface.
  */
-export default class WindowCWISubstrate implements Wallet {
-  private CWI: Wallet
+export default class WindowCWISubstrate implements WalletInterface {
+  private CWI: WalletInterface
   constructor() {
     if (typeof window !== 'object') {
       throw new Error('The window.CWI substrate requires a global window object.')
@@ -16,7 +16,7 @@ export default class WindowCWISubstrate implements Wallet {
     if (typeof window.CWI !== 'object') {
       throw new Error('The window.CWI interface does not appear to be bound to the window object.')
     }
-    this.CWI = window.CWI as Wallet // Binding CWI to prevent changes
+    this.CWI = window.CWI as WalletInterface // Binding CWI to prevent changes
   }
 
   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[] } }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{ txid?: TXIDHexString, tx?: BEEF, noSendChange?: OutpointString[], sendWithResults?: Array<{ txid: TXIDHexString, status: 'unproven' | 'sending' | 'failed' }>, signableTransaction?: { tx: BEEF, reference: Base64String } }> {