@bsv/sdk 1.3.8 → 1.3.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/sdk",
-  "version": "1.3.8",
+  "version": "1.3.9",
   "type": "module",
   "description": "BSV Blockchain Software Development Kit",
   "main": "dist/cjs/mod.js",

package/src/auth/Peer.ts

@@ -2,7 +2,7 @@ import { SessionManager } from './SessionManager.js'
 import { createNonce, verifyNonce, getVerifiableCertificates, validateCertificates } from './utils/index.js'
 import { AuthMessage, PeerSession, RequestedCertificateSet, Transport } from './types.js'
 import { VerifiableCertificate } from './certificates/VerifiableCertificate.js'
-import { Random, Utils, Wallet } from '../../mod.js'
+import { Random, Utils, WalletInterface } from '../../mod.js'
 
 const AUTH_VERSION = '0.1'
 
@@ -14,7 +14,7 @@ const AUTH_VERSION = '0.1'
 export class Peer {
   public sessionManager: SessionManager
   private readonly transport: Transport
-  private readonly wallet: Wallet
+  private readonly wallet: WalletInterface
   certificatesToRequest: RequestedCertificateSet
   private readonly onGeneralMessageReceivedCallbacks: Map<number, (senderPublicKey: string, payload: number[]) => void> = new Map()
   private readonly onCertificatesReceivedCallbacks: Map<number, (senderPublicKey: string, certs: VerifiableCertificate[]) => void> = new Map()
@@ -33,14 +33,14 @@ export class Peer {
   /**
    * Creates a new Peer instance
    *
-   * @param {Wallet} wallet - The wallet instance used for cryptographic operations.
+   * @param {WalletInterface} wallet - The wallet instance used for cryptographic operations.
    * @param {Transport} transport - The transport mechanism used for sending and receiving messages.
    * @param {RequestedCertificateSet} [certificatesToRequest] - Optional set of certificates to request from a peer during the initial handshake.
    * @param {SessionManager} [sessionManager] - Optional SessionManager to be used for managing peer sessions.
    * @param {boolean} [autoPersistLastSession] - Whether to auto-persist the session with the last-interacted-with peer. Defaults to true.
    */
-  constructor (
-    wallet: Wallet,
+  constructor(
+    wallet: WalletInterface,
     transport: Transport,
     certificatesToRequest?: RequestedCertificateSet,
     sessionManager?: SessionManager,
@@ -66,7 +66,7 @@ export class Peer {
    * @returns {Promise<void>}
    * @throws Will throw an error if the message fails to send.
    */
-  async toPeer (message: number[], identityKey?: string, maxWaitTime?: number): Promise<void> {
+  async toPeer(message: number[], identityKey?: string, maxWaitTime?: number): Promise<void> {
     if (this.autoPersistLastSession && this.lastInteractedWithPeer && typeof identityKey !== 'string') {
       identityKey = this.lastInteractedWithPeer
     }
@@ -111,7 +111,7 @@ export class Peer {
   * @returns {Promise<void>} Resolves if the certificate request message is successfully sent.
   * @throws Will throw an error if the peer session is not authenticated or if sending the request fails.
   */
-  async requestCertificates (certificatesToRequest: RequestedCertificateSet, identityKey?: string, maxWaitTime = 10000): Promise<void> {
+  async requestCertificates(certificatesToRequest: RequestedCertificateSet, identityKey?: string, maxWaitTime = 10000): Promise<void> {
     const peerSession = await this.getAuthenticatedSession(identityKey, maxWaitTime)
 
     // Prepare the general message
@@ -152,7 +152,7 @@ export class Peer {
    * @returns {Promise<PeerSession>} - A promise that resolves with an authenticated `PeerSession`.
    * @throws {Error} - Throws an error if the transport is not connected or if the handshake fails.
    */
-  async getAuthenticatedSession (identityKey?: string, maxWaitTime?: number): Promise<PeerSession> {
+  async getAuthenticatedSession(identityKey?: string, maxWaitTime?: number): Promise<PeerSession> {
     if (!this.transport) {
       throw new Error('Peer transport is not connected!')
     }
@@ -175,7 +175,7 @@ export class Peer {
    * @param {(senderPublicKey: string, payload: number[]) => void} callback - The function to call when a general message is received.
    * @returns {number} The ID of the callback listener.
    */
-  listenForGeneralMessages (callback: (senderPublicKey: string, payload: number[]) => void): number {
+  listenForGeneralMessages(callback: (senderPublicKey: string, payload: number[]) => void): number {
     const callbackID = this.callbackIdCounter++
     this.onGeneralMessageReceivedCallbacks.set(callbackID, callback)
     return callbackID
@@ -186,7 +186,7 @@ export class Peer {
    *
    * @param {number} callbackID - The ID of the callback to remove.
    */
-  stopListeningForGeneralMessages (callbackID: number): void {
+  stopListeningForGeneralMessages(callbackID: number): void {
     this.onGeneralMessageReceivedCallbacks.delete(callbackID)
   }
 
@@ -196,7 +196,7 @@ export class Peer {
    * @param {(certs: VerifiableCertificate[]) => void} callback - The function to call when certificates are received.
    * @returns {number} The ID of the callback listener.
    */
-  listenForCertificatesReceived (callback: (senderPublicKey: string, certs: VerifiableCertificate[]) => void): number {
+  listenForCertificatesReceived(callback: (senderPublicKey: string, certs: VerifiableCertificate[]) => void): number {
     const callbackID = this.callbackIdCounter++
     this.onCertificatesReceivedCallbacks.set(callbackID, callback)
     return callbackID
@@ -207,7 +207,7 @@ export class Peer {
    *
    * @param {number} callbackID - The ID of the certificates received callback to cancel.
    */
-  stopListeningForCertificatesReceived (callbackID: number): void {
+  stopListeningForCertificatesReceived(callbackID: number): void {
     this.onCertificatesReceivedCallbacks.delete(callbackID)
   }
 
@@ -217,7 +217,7 @@ export class Peer {
    * @param {(requestedCertificates: RequestedCertificateSet) => void} callback - The function to call when a certificate request is received
    * @returns {number} The ID of the callback listener.
    */
-  listenForCertificatesRequested (callback: (senderPublicKey: string, requestedCertificates: RequestedCertificateSet) => void): number {
+  listenForCertificatesRequested(callback: (senderPublicKey: string, requestedCertificates: RequestedCertificateSet) => void): number {
     const callbackID = this.callbackIdCounter++
     this.onCertificateRequestReceivedCallbacks.set(callbackID, callback)
     return callbackID
@@ -228,7 +228,7 @@ export class Peer {
    *
    * @param {number} callbackID - The ID of the requested certificates callback to cancel.
    */
-  stopListeningForCertificatesRequested (callbackID: number): void {
+  stopListeningForCertificatesRequested(callbackID: number): void {
     this.onCertificateRequestReceivedCallbacks.delete(callbackID)
   }
 
@@ -239,7 +239,7 @@ export class Peer {
    * @param {string} [identityKey] - The identity public key of the peer.
    * @returns {Promise<string>} A promise that resolves to the session nonce.
    */
-  private async initiateHandshake (identityKey?: string, maxWaitTime = 10000): Promise<string> {
+  private async initiateHandshake(identityKey?: string, maxWaitTime = 10000): Promise<string> {
     const sessionNonce = await createNonce(this.wallet) // Initial request nonce
     this.sessionManager.addSession({
       isAuthenticated: false,
@@ -265,7 +265,7 @@ export class Peer {
    * @param {string} sessionNonce - The session nonce created in the initial request.
    * @returns {Promise<string>} A promise that resolves with the session nonce when the initial response is received.
    */
-  private async waitForInitialResponse (sessionNonce: string, maxWaitTime = 10000): Promise<string> {
+  private async waitForInitialResponse(sessionNonce: string, maxWaitTime = 10000): Promise<string> {
     return await new Promise((resolve, reject) => {
       const callbackID = this.listenForInitialResponse(sessionNonce, (sessionNonce) => {
         clearTimeout(timeoutHandle)
@@ -288,7 +288,7 @@ export class Peer {
    * @param {(sessionNonce: string) => void} callback - The callback to invoke when the initial response is received.
    * @returns {number} The ID of the callback listener.
    */
-  private listenForInitialResponse (sessionNonce: string, callback: (sessionNonce: string) => void) {
+  private listenForInitialResponse(sessionNonce: string, callback: (sessionNonce: string) => void) {
     const callbackID = this.callbackIdCounter++
     this.onInitialResponseReceivedCallbacks.set(callbackID, { callback, sessionNonce })
     return callbackID
@@ -300,7 +300,7 @@ export class Peer {
    * @private
    * @param {number} callbackID - The ID of the callback to remove.
    */
-  private stopListeningForInitialResponses (callbackID: number) {
+  private stopListeningForInitialResponses(callbackID: number) {
     this.onInitialResponseReceivedCallbacks.delete(callbackID)
   }
 
@@ -310,7 +310,7 @@ export class Peer {
    * @param {AuthMessage} message - The incoming message to process.
    * @returns {Promise<void>}
    */
-  private async handleIncomingMessage (message: AuthMessage): Promise<void> {
+  private async handleIncomingMessage(message: AuthMessage): Promise<void> {
     if (!message.version || message.version !== AUTH_VERSION) {
       console.error(`Invalid message auth version! Received: ${message.version}, expected: ${AUTH_VERSION}`)
       return
@@ -343,7 +343,7 @@ export class Peer {
    * @param {AuthMessage} message - The incoming initial request message.
    * @returns {Promise<void>}
    */
-  async processInitialRequest (message: AuthMessage) {
+  async processInitialRequest(message: AuthMessage) {
     if (!message.identityKey || !message.initialNonce) {
       throw new Error('Missing required fields in initialResponse message.')
     }
@@ -406,7 +406,7 @@ export class Peer {
    * @returns {Promise<void>}
    * @throws Will throw an error if nonce verification or signature verification fails.
    */
-  private async processInitialResponse (message: AuthMessage) {
+  private async processInitialResponse(message: AuthMessage) {
     const validNonce = await verifyNonce(message.yourNonce, this.wallet)
     if (!validNonce) {
       throw new Error(`Initial response nonce verification failed from peer: ${message.identityKey}`)
@@ -478,7 +478,7 @@ export class Peer {
    * @param {AuthMessage} message - The certificate request message received from the peer.
    * @throws {Error} Throws an error if nonce verification fails, or the message signature is invalid.
    */
-  private async processCertificateRequest (message: AuthMessage) {
+  private async processCertificateRequest(message: AuthMessage) {
     const validNonce = await verifyNonce(message.yourNonce, this.wallet)
     if (!validNonce) {
       throw new Error(`Unable to verify nonce for certificate request message from: ${message.identityKey}`)
@@ -520,7 +520,7 @@ export class Peer {
    *
    * @throws {Error} Throws an error if the peer session could not be authenticated or if message signing fails.
    */
-  async sendCertificateResponse (
+  async sendCertificateResponse(
     verifierIdentityKey: string,
     certificates: VerifiableCertificate[]
   ) {
@@ -559,7 +559,7 @@ export class Peer {
    * @returns {Promise<void>}
    * @throws Will throw an error if nonce verification or signature verification fails.
    */
-  private async processCertificateResponse (
+  private async processCertificateResponse(
     message: AuthMessage
   ) {
     const validNonce = await verifyNonce(message.yourNonce, this.wallet)
@@ -597,7 +597,7 @@ export class Peer {
    * @returns {Promise<void>}
    * @throws Will throw an error if nonce verification or signature verification fails.
    */
-  private async processGeneralMessage (message: AuthMessage) {
+  private async processGeneralMessage(message: AuthMessage) {
     const validNonce = await verifyNonce(message.yourNonce, this.wallet)
     if (!validNonce) {
       throw new Error(`Unable to verify nonce for general message from: ${message.identityKey}`)

package/src/auth/certificates/Certificate.ts

@@ -5,9 +5,10 @@ import {
   HexString,
   OutpointString,
   CertificateFieldNameUnder50Bytes,
-  ProtoWallet,
+  WalletInterface,
   Signature,
-  WalletProtocol
+  WalletProtocol,
+  ProtoWallet
 } from '../../../mod.js'
 
 /**
@@ -231,7 +232,7 @@ export default class Certificate {
    * @param {Wallet} certifierWallet - The wallet representing the certifier.
    * @returns {Promise<void>}
    */
-  async sign(certifierWallet: ProtoWallet): Promise<void> {
+  async sign(certifierWallet: WalletInterface): Promise<void> {
     if (this.signature) {
       throw new Error(`Certificate has already been signed! Signature present: ${this.signature}`)
     }

package/src/auth/certificates/MasterCertificate.ts

@@ -6,9 +6,9 @@ import {
   HexString,
   OutpointString,
   PubKeyHex,
-  ProtoWallet,
   Random,
-  WalletCounterparty
+  WalletCounterparty,
+  WalletInterface
 } from '../../../mod.js'
 import Certificate from './Certificate.js'
 
@@ -61,12 +61,12 @@ export class MasterCertificate extends Certificate {
    * This method uses the `masterKeyring` to decrypt each field's encryption key and then
    * decrypts the field values. The result is a record of plaintext field names and values.
    * 
-   * @param {ProtoWallet} subjectWallet - The wallet of the subject, used to decrypt the master keyring and field values.
+   * @param {WalletInterface} subjectWallet - The wallet of the subject, used to decrypt the master keyring and field values.
    * @returns {Promise<Record<CertificateFieldNameUnder50Bytes, string>>} - A record of field names and their decrypted values in plaintext.
    * 
    * @throws {Error} Throws an error if the `masterKeyring` is invalid or if decryption fails for any field.
    */
-  async decryptFields(subjectWallet: ProtoWallet): Promise<Record<CertificateFieldNameUnder50Bytes, string>> {
+  async decryptFields(subjectWallet: WalletInterface): Promise<Record<CertificateFieldNameUnder50Bytes, string>> {
     // const fields: Record<CertificateFieldNameUnder50Bytes, Base64String> = this.fields
     const decryptedFields: Record<CertificateFieldNameUnder50Bytes, string> = {}
     if (!this.masterKeyring || Object.keys(this.masterKeyring).length === 0) {
@@ -97,7 +97,7 @@ export class MasterCertificate extends Certificate {
    * for the verifier's identity key. The result is a keyring containing the keys necessary
    * for the verifier to access the designated fields.
    *
-   * @param {ProtoWallet} subjectWallet - The wallet instance of the subject, used to decrypt and re-encrypt field keys.
+   * @param {WalletInterface} subjectWallet - The wallet instance of the subject, used to decrypt and re-encrypt field keys.
    * @param {WalletCounterparty} verifier - The verifier who will receive access to the selectively revealed fields. Can be an identity key as hex, 'anyone', or 'self'.
    * @param {string[]} fieldsToReveal - An array of field names to be revealed to the verifier. Must be a subset of the certificate's fields.
    * @param {string} [originator] - Optional originator identifier, used if additional context is needed for decryption and encryption operations.
@@ -107,7 +107,7 @@ export class MasterCertificate extends Certificate {
    *   - A field in `fieldsToReveal` does not exist in the certificate.
    *   - The decrypted master field key fails to decrypt the corresponding field (indicating an invalid key).
    */
-  async createKeyringForVerifier(subjectWallet: ProtoWallet, verifier: WalletCounterparty, fieldsToReveal: string[], originator?: string): Promise<Record<CertificateFieldNameUnder50Bytes, string>> {
+  async createKeyringForVerifier(subjectWallet: WalletInterface, verifier: WalletCounterparty, fieldsToReveal: string[], originator?: string): Promise<Record<CertificateFieldNameUnder50Bytes, string>> {
     if (!Array.isArray(fieldsToReveal)) {
       throw new Error('fieldsToReveal must be an array of strings')
     }
@@ -157,7 +157,7 @@ export class MasterCertificate extends Certificate {
    * generated symmetric key, which is then encrypted for the subject. The certificate
    * can also includes a revocation outpoint to manage potential revocation.
    * 
-   * @param {ProtoWallet} certifierWallet - The wallet of the certifier, used to sign the certificate and encrypt field keys.
+   * @param {WalletInterface} certifierWallet - The wallet of the certifier, used to sign the certificate and encrypt field keys.
    * @param {WalletCounterparty} subject - The subject for whom the certificate is issued.
    * @param {Record<CertificateFieldNameUnder50Bytes, string>} fields - Unencrypted certificate fields to include, with their names and values.
    * @param {string} certificateType - The type of certificate being issued.
@@ -169,7 +169,7 @@ export class MasterCertificate extends Certificate {
    * @throws {Error} Throws an error if any operation (e.g., encryption, signing) fails during certificate issuance.
    */
   static async issueCertificateForSubject(
-    certifierWallet: ProtoWallet,
+    certifierWallet: WalletInterface,
     subject: WalletCounterparty,
     fields: Record<CertificateFieldNameUnder50Bytes, string>,
     certificateType: string,

package/src/auth/certificates/VerifiableCertificate.ts

@@ -6,7 +6,7 @@ import {
   HexString,
   OutpointString,
   PubKeyHex,
-  Wallet,
+  WalletInterface,
   WalletError
 } from '../../../mod.js'
 import Certificate from './Certificate.js'
@@ -45,11 +45,11 @@ export class VerifiableCertificate extends Certificate {
 
   /**
    * Decrypts selectively revealed certificate fields using the provided keyring and verifier wallet
-   * @param {Wallet} verifierWallet - The wallet instance of the certificate's verifier, used to decrypt field keys.
+   * @param {WalletInterface} verifierWallet - The wallet instance of the certificate's verifier, used to decrypt field keys.
    * @returns {Promise<Record<CertificateFieldNameUnder50Bytes, string>>} - A promise that resolves to an object where each key is a field name and each value is the decrypted field value as a string.
    * @throws {Error} Throws an error if any of the decryption operations fail, with a message indicating the failure context.
    */
-  async decryptFields(verifierWallet: Wallet): Promise<Record<CertificateFieldNameUnder50Bytes, string>> {
+  async decryptFields(verifierWallet: WalletInterface): Promise<Record<CertificateFieldNameUnder50Bytes, string>> {
     if (!this.keyring || Object.keys(this.keyring).length === 0) {
       throw new Error('A keyring is required to decrypt certificate fields for the verifier.')
     }

package/src/auth/certificates/__tests/CompletedProtoWallet.ts

@@ -1,9 +1,9 @@
 import { PrivateKey } from "mod.js"
-import { ProtoWallet, Wallet, CreateActionArgs, OriginatorDomainNameStringUnder250Bytes, CreateActionResult, SignActionArgs, SignActionResult, AbortActionArgs, AbortActionResult, ListActionsArgs, ListActionsResult, InternalizeActionArgs, InternalizeActionResult, ListOutputsArgs, ListOutputsResult, RelinquishOutputArgs, RelinquishOutputResult, AcquireCertificateArgs, AcquireCertificateResult, ListCertificatesArgs, ListCertificatesResult, ProveCertificateArgs, ProveCertificateResult, RelinquishCertificateArgs, RelinquishCertificateResult, DiscoverByIdentityKeyArgs, DiscoverCertificatesResult, DiscoverByAttributesArgs, GetHeightResult, GetHeaderArgs, GetHeaderResult, KeyDeriverApi, KeyDeriver, GetPublicKeyArgs, GetPublicKeyResult, PubKeyHex } from "../../../wallet/index.js"
+import { ProtoWallet, WalletInterface, CreateActionArgs, OriginatorDomainNameStringUnder250Bytes, CreateActionResult, SignActionArgs, SignActionResult, AbortActionArgs, AbortActionResult, ListActionsArgs, ListActionsResult, InternalizeActionArgs, InternalizeActionResult, ListOutputsArgs, ListOutputsResult, RelinquishOutputArgs, RelinquishOutputResult, AcquireCertificateArgs, AcquireCertificateResult, ListCertificatesArgs, ListCertificatesResult, ProveCertificateArgs, ProveCertificateResult, RelinquishCertificateArgs, RelinquishCertificateResult, DiscoverByIdentityKeyArgs, DiscoverCertificatesResult, DiscoverByAttributesArgs, GetHeightResult, GetHeaderArgs, GetHeaderResult, KeyDeriverApi, KeyDeriver, GetPublicKeyArgs, GetPublicKeyResult, PubKeyHex, AuthenticatedResult, GetNetworkResult, GetVersionResult } from "../../../wallet/index.js"
 
 // Test Mock wallet which extends ProtoWallet but still implements Wallet interface
 // Unsupported methods throw
-export class CompletedProtoWallet extends ProtoWallet implements Wallet {
+export class CompletedProtoWallet extends ProtoWallet implements WalletInterface {
   constructor(rootKeyOrKeyDeriver: PrivateKey | 'anyone' | KeyDeriverApi) {
     super(rootKeyOrKeyDeriver)
     if (typeof rootKeyOrKeyDeriver['identityKey'] !== 'string') {
@@ -11,7 +11,18 @@ export class CompletedProtoWallet extends ProtoWallet implements Wallet {
     }
     this.keyDeriver = rootKeyOrKeyDeriver as KeyDeriver
   }
-
+  isAuthenticated(args: {}, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<AuthenticatedResult> {
+    throw new Error("not implemented")
+  }
+  waitForAuthentication(args: {}, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<AuthenticatedResult> {
+    throw new Error("not implemented")
+  }
+  getNetwork(args: {}, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<GetNetworkResult> {
+    throw new Error("not implemented")
+  }
+  getVersion(args: {}, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<GetVersionResult> {
+    throw new Error("not implemented")
+  }
   async getPublicKey(
     args: GetPublicKeyArgs,
     originator?: OriginatorDomainNameStringUnder250Bytes

package/src/auth/clients/AuthFetch.ts

@@ -1,4 +1,4 @@
-import { Utils, Random, P2PKH, PublicKey, Wallet } from '../../../mod.js'
+import { Utils, Random, P2PKH, PublicKey, WalletInterface } from '../../../mod.js'
 import { Peer } from '../Peer.js'
 import { SimplifiedFetchTransport } from '../transports/SimplifiedFetchTransport.js'
 import { SessionManager } from '../SessionManager.js'
@@ -26,7 +26,7 @@ const PAYMENT_VERSION = '1.0'
  */
 export class AuthFetch {
   private sessionManager: SessionManager
-  private wallet: Wallet
+  private wallet: WalletInterface
   private callbacks: Record<string, { resolve: Function, reject: Function }> = {}
   private certificatesReceived: VerifiableCertificate[] = []
   private requestedCertificates?: RequestedCertificateSet
@@ -37,7 +37,7 @@ export class AuthFetch {
   * @param wallet - The wallet instance for signing and authentication.
   * @param requestedCertificates - Optional set of certificates to request from peers.
   */
-  constructor(wallet: Wallet, requestedCertificates?: RequestedCertificateSet, sessionManager?: SessionManager) {
+  constructor(wallet: WalletInterface, requestedCertificates?: RequestedCertificateSet, sessionManager?: SessionManager) {
     this.wallet = wallet
     this.requestedCertificates = requestedCertificates
     this.sessionManager = sessionManager || new SessionManager()

package/src/auth/utils/createNonce.ts

@@ -1,11 +1,11 @@
-import { Utils, Random, Wallet } from '../../../mod.js'
+import { Utils, Random, WalletInterface } from '../../../mod.js'
 
 /**
  * Creates a nonce derived from a privateKey
  * @param wallet
  * @returns A random nonce derived with a wallet
  */
-export async function createNonce(wallet: Wallet): Promise<string> {
+export async function createNonce(wallet: WalletInterface): Promise<string> {
   // Generate 16 random bytes for the first half of the data
   const firstHalf = Random(16)
   // Create an sha256 HMAC

package/src/auth/utils/getVerifiableCertificates.ts

@@ -1,5 +1,5 @@
 import { VerifiableCertificate } from "../certificates/VerifiableCertificate.js"
-import { Wallet } from "../../../mod.js"
+import { WalletInterface } from "../../../mod.js"
 import { RequestedCertificateSet } from "../types.js"
 
 /**
@@ -10,7 +10,7 @@ import { RequestedCertificateSet } from "../types.js"
  * @param {string} verifierIdentityKey - The public key of the verifier requesting the certificates.
  * @returns {Promise<VerifiableCertificate[]>} An array of verifiable certificates.
  */
-export const getVerifiableCertificates = async (wallet: Wallet, requestedCertificates: RequestedCertificateSet, verifierIdentityKey: string): Promise<VerifiableCertificate[]> => {
+export const getVerifiableCertificates = async (wallet: WalletInterface, requestedCertificates: RequestedCertificateSet, verifierIdentityKey: string): Promise<VerifiableCertificate[]> => {
   // Find matching certificates we have
   // Note: This may return multiple certificates that match the correct type.
   const matchingCertificates = await wallet.listCertificates({

package/src/auth/utils/validateCertificates.ts

@@ -1,4 +1,4 @@
-import { Wallet } from "../../wallet/index.js"
+import { WalletInterface } from "../../wallet/index.js"
 import { AuthMessage, RequestedCertificateSet } from "../types.js"
 import { VerifiableCertificate } from "../certificates/VerifiableCertificate.js"
 
@@ -10,7 +10,7 @@ import { VerifiableCertificate } from "../certificates/VerifiableCertificate.js"
  * @returns {Promise<void>}
  * @throws Will throw an error if certificate validation or field decryption fails.
  */
-export const validateCertificates = async (verifierWallet: Wallet, message: AuthMessage, certificatesRequested?: RequestedCertificateSet): Promise<void> => {
+export const validateCertificates = async (verifierWallet: WalletInterface, message: AuthMessage, certificatesRequested?: RequestedCertificateSet): Promise<void> => {
   await Promise.all(message.certificates.map(async (incomingCert: VerifiableCertificate) => {
     if (incomingCert.subject !== message.identityKey) {
       throw new Error(`The subject of one of your certificates ("${incomingCert.subject}") is not the same as the request sender ("${message.identityKey}").`)

package/src/auth/utils/verifyNonce.ts

@@ -1,4 +1,4 @@
-import { Utils, Wallet } from '../../../mod.js'
+import { Utils, WalletInterface } from '../../../mod.js'
 
 /**
  * Verifies a nonce derived from a wallet
@@ -6,7 +6,7 @@ import { Utils, Wallet } from '../../../mod.js'
  * @param wallet
  * @returns The status of the validation
  */
-export async function verifyNonce(nonce: string, wallet: Wallet): Promise<boolean> {
+export async function verifyNonce(nonce: string, wallet: WalletInterface): Promise<boolean> {
   // Convert nonce from base64 string to Uint8Array
   const buffer = Utils.toArray(nonce, 'base64')
 

package/src/overlay-tools/OverlayAdminTokenTemplate.ts

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

package/src/script/templates/PushDrop.ts

@@ -1,6 +1,6 @@
 import { ScriptTemplate, LockingScript, UnlockingScript, OP } from '../index.js'
 import { Utils, Hash, TransactionSignature, Signature, PublicKey } from '../../primitives/index.js'
-import { Wallet } from '../../wallet/Wallet.interfaces.js'
+import { WalletInterface } from '../../wallet/Wallet.interfaces.js'
 import { Transaction } from '../../transaction/index.js'
 import { SecurityLevel } from '../../wallet/Wallet.interfaces.js'
 
@@ -44,7 +44,7 @@ const createMinimallyEncodedScriptChunk = (data: number[]): { op: number, data?:
 }
 
 export default class PushDrop implements ScriptTemplate {
-  wallet: Wallet
+  wallet: WalletInterface
 
   /**
    * Decodes a PushDrop script back into its token fields and the locking public key. If a signature was present, it will be the last field returned.
@@ -84,9 +84,9 @@ export default class PushDrop implements ScriptTemplate {
   /**
    * Constructs a new instance of the PushDrop class.
    *
-   * @param {Wallet} wallet - The wallet interface used for creating signatures and accessing public keys.
+   * @param {WalletInterface} wallet - The wallet interface used for creating signatures and accessing public keys.
    */
-  constructor(wallet: Wallet) {
+  constructor(wallet: WalletInterface) {
     this.wallet = wallet
   }