@bsv/sdk 1.3.12 → 1.3.13

package/src/auth/utils/__tests/getVerifiableCertificates.test.ts

@@ -1,25 +1,25 @@
-import { Wallet } from '../../../../dist/cjs/src/wallet/Wallet.interfaces.js'
-import { getVerifiableCertificates } from '../../../../dist/cjs/src/auth/utils/getVerifiableCertificates'
-import { RequestedCertificateSet } from '../../../../dist/cjs/src/auth/types.js'
-import { VerifiableCertificate } from '../../../../dist/cjs/src/auth/certificates/VerifiableCertificate.js'
+import { WalletInterface } from '../../../wallet/Wallet.interfaces'
+import { getVerifiableCertificates } from '../../../auth/utils/getVerifiableCertificates'
+import { RequestedCertificateSet } from '../../../auth/types'
+import { VerifiableCertificate } from '../../../auth/certificates/VerifiableCertificate'
 
 describe('getVerifiableCertificates', () => {
-  let mockWallet: Wallet
+  let mockWallet: WalletInterface
   let requestedCertificates: RequestedCertificateSet
   let verifierIdentityKey: string
 
   beforeEach(() => {
     mockWallet = {
       listCertificates: jest.fn(),
-      proveCertificate: jest.fn(),
-    } as unknown as Wallet
+      proveCertificate: jest.fn()
+    } as unknown as WalletInterface
 
     requestedCertificates = {
       certifiers: ['certifier1', 'certifier2'],
       types: {
         certType1: ['field1', 'field2'],
-        certType2: ['field3'],
-      },
+        certType2: ['field3']
+      }
     }
 
     verifierIdentityKey = 'verifier_public_key'
@@ -33,27 +33,31 @@ describe('getVerifiableCertificates', () => {
       certifier: 'certifier1',
       revocationOutpoint: 'outpoint1',
       fields: { field1: 'encryptedData1', field2: 'encryptedData2' },
-      signature: 'signature1',
-    };
+      signature: 'signature1'
+    }
 
-    (mockWallet.listCertificates as jest.Mock).mockResolvedValue({
+    ;(mockWallet.listCertificates as jest.Mock).mockResolvedValue({
       certificates: [mockCertificate]
-    });
-    (mockWallet.proveCertificate as jest.Mock).mockResolvedValue({
+    })
+    ;(mockWallet.proveCertificate as jest.Mock).mockResolvedValue({
       keyringForVerifier: { field1: 'key1', field2: 'key2' }
     })
 
-    const result = await getVerifiableCertificates(mockWallet, requestedCertificates, verifierIdentityKey)
+    const result = await getVerifiableCertificates(
+      mockWallet,
+      requestedCertificates,
+      verifierIdentityKey
+    )
 
     expect(mockWallet.listCertificates).toHaveBeenCalledWith({
       certifiers: requestedCertificates.certifiers,
-      types: Object.keys(requestedCertificates.types),
+      types: Object.keys(requestedCertificates.types)
     })
 
     expect(mockWallet.proveCertificate).toHaveBeenCalledWith({
       certificate: mockCertificate,
       fieldsToReveal: requestedCertificates.types[mockCertificate.type],
-      verifier: verifierIdentityKey,
+      verifier: verifierIdentityKey
     })
 
     expect(result).toHaveLength(1)
@@ -70,11 +74,16 @@ describe('getVerifiableCertificates', () => {
     })
   })
 
-
   it('returns an empty array when no matching certificates are found', async () => {
-    (mockWallet.listCertificates as jest.Mock).mockResolvedValue({ certificates: [] })
+    ;(mockWallet.listCertificates as jest.Mock).mockResolvedValue({
+      certificates: []
+    })
 
-    const result = await getVerifiableCertificates(mockWallet, requestedCertificates, verifierIdentityKey)
+    const result = await getVerifiableCertificates(
+      mockWallet,
+      requestedCertificates,
+      verifierIdentityKey
+    )
 
     expect(result).toEqual([])
     expect(mockWallet.listCertificates).toHaveBeenCalled()
@@ -82,11 +91,17 @@ describe('getVerifiableCertificates', () => {
   })
 
   it('propagates errors from listCertificates', async () => {
-    (mockWallet.listCertificates as jest.Mock).mockRejectedValue(new Error('listCertificates failed'))
-
-    await expect(getVerifiableCertificates(mockWallet, requestedCertificates, verifierIdentityKey)).rejects.toThrow(
-      'listCertificates failed'
+    ;(mockWallet.listCertificates as jest.Mock).mockRejectedValue(
+      new Error('listCertificates failed')
     )
+
+    await expect(
+      getVerifiableCertificates(
+        mockWallet,
+        requestedCertificates,
+        verifierIdentityKey
+      )
+    ).rejects.toThrow('listCertificates failed')
   })
 
   it('propagates errors from proveCertificate', async () => {
@@ -97,30 +112,41 @@ describe('getVerifiableCertificates', () => {
       certifier: 'certifier1',
       revocationOutpoint: 'outpoint1',
       fields: { field1: 'encryptedData1', field2: 'encryptedData2' },
-      signature: 'signature1',
-    };
-
-    (mockWallet.listCertificates as jest.Mock).mockResolvedValue({
-      certificates: [mockCertificate],
-    });
-    (mockWallet.proveCertificate as jest.Mock).mockRejectedValue(new Error('proveCertificate failed'))
+      signature: 'signature1'
+    }
 
-    await expect(getVerifiableCertificates(mockWallet, requestedCertificates, verifierIdentityKey)).rejects.toThrow(
-      'proveCertificate failed'
+    ;(mockWallet.listCertificates as jest.Mock).mockResolvedValue({
+      certificates: [mockCertificate]
+    })
+    ;(mockWallet.proveCertificate as jest.Mock).mockRejectedValue(
+      new Error('proveCertificate failed')
     )
+
+    await expect(
+      getVerifiableCertificates(
+        mockWallet,
+        requestedCertificates,
+        verifierIdentityKey
+      )
+    ).rejects.toThrow('proveCertificate failed')
   })
 
   it('handles empty requested certificates gracefully', async () => {
-    requestedCertificates = { certifiers: [], types: {} };
-
-    (mockWallet.listCertificates as jest.Mock).mockResolvedValue({ certificates: [] })
+    requestedCertificates = { certifiers: [], types: {} }
+    ;(mockWallet.listCertificates as jest.Mock).mockResolvedValue({
+      certificates: []
+    })
 
-    const result = await getVerifiableCertificates(mockWallet, requestedCertificates, verifierIdentityKey)
+    const result = await getVerifiableCertificates(
+      mockWallet,
+      requestedCertificates,
+      verifierIdentityKey
+    )
 
     expect(result).toEqual([])
     expect(mockWallet.listCertificates).toHaveBeenCalledWith({
       certifiers: [],
-      types: [],
+      types: []
     })
   })
 })

package/src/auth/utils/__tests/validateCertificates.test.ts

@@ -1,142 +1,154 @@
-import { validateCertificates } from '../../../../dist/cjs/src/auth/utils/validateCertificates.js'
-import { VerifiableCertificate } from '../../../../dist/cjs/src/auth/certificates/VerifiableCertificate.js'
-import { ProtoWallet } from '../../../../dist/cjs/src/wallet/index.js'
-import { PrivateKey } from '../../../../dist/cjs/src/primitives/index.js'
-
-let mockVerify = jest.fn(() => Promise.resolve(true))
-let mockDecryptFields = jest.fn(() => Promise.resolve({ field1: 'decryptedValue1' }))
-const mockInstances = []
-
-jest.mock('../../../../dist/cjs/src/auth/certificates/VerifiableCertificate.js', () => {
+import { validateCertificates } from "../../../auth/utils/validateCertificates";
+import { VerifiableCertificate } from "../../../auth/certificates/VerifiableCertificate";
+import { ProtoWallet } from "../../../wallet/index";
+import { PrivateKey } from "../../../primitives/index";
+
+let mockVerify = jest.fn(() => Promise.resolve(true));
+let mockDecryptFields = jest.fn(() =>
+  Promise.resolve({ field1: "decryptedValue1" })
+);
+const mockInstances = [];
+
+jest.mock("../../../auth/certificates/VerifiableCertificate", () => {
   return {
     VerifiableCertificate: jest.fn().mockImplementation(() => {
       const instance = {
-        type: 'requested_type',
-        serialNumber: 'valid_serial',
-        subject: 'valid_subject',
-        certifier: 'valid_certifier',
-        revocationOutpoint: 'outpoint',
-        fields: { field1: 'encryptedData1' },
+        type: "requested_type",
+        serialNumber: "valid_serial",
+        subject: "valid_subject",
+        certifier: "valid_certifier",
+        revocationOutpoint: "outpoint",
+        fields: { field1: "encryptedData1" },
         decryptedFields: {},
         verify: mockVerify,
         decryptFields: mockDecryptFields,
-      }
-      mockInstances.push(instance)
-      return instance
+      };
+      mockInstances.push(instance);
+      return instance;
     }),
-  }
-})
+  };
+});
 
-describe('validateCertificates', () => {
-  let verifierWallet
-  let message
+describe("validateCertificates", () => {
+  let verifierWallet;
+  let message;
 
   beforeEach(() => {
-    jest.clearAllMocks()
-    mockInstances.length = 0 // Clear tracked instances
+    jest.clearAllMocks();
+    mockInstances.length = 0; // Clear tracked instances
 
     // Reset state
-    mockVerify = jest.fn(() => Promise.resolve(true))
-    mockDecryptFields = jest.fn(() => Promise.resolve({ field1: 'decryptedValue1' }))
+    mockVerify = jest.fn(() => Promise.resolve(true));
+    mockDecryptFields = jest.fn(() =>
+      Promise.resolve({ field1: "decryptedValue1" })
+    );
 
-    verifierWallet = new ProtoWallet(new PrivateKey(1))
+    verifierWallet = new ProtoWallet(new PrivateKey(1));
     message = {
-      identityKey: 'valid_subject',
+      identityKey: "valid_subject",
       certificates: [
         {
-          type: 'requested_type',
-          serialNumber: 'valid_serial',
-          subject: 'valid_subject',
-          certifier: 'valid_certifier',
-          revocationOutpoint: 'outpoint',
-          fields: { field1: 'encryptedData1' },
+          type: "requested_type",
+          serialNumber: "valid_serial",
+          subject: "valid_subject",
+          certifier: "valid_certifier",
+          revocationOutpoint: "outpoint",
+          fields: { field1: "encryptedData1" },
           decryptedFields: {},
         },
       ],
-    }
-  })
+    };
+  });
 
-  it('completes without errors for valid input', async () => {
-    await expect(validateCertificates(verifierWallet, message)).resolves.not.toThrow()
+  it("completes without errors for valid input", async () => {
+    await expect(
+      validateCertificates(verifierWallet, message)
+    ).resolves.not.toThrow();
 
-    expect(VerifiableCertificate).toHaveBeenCalledTimes(message.certificates.length)
-    expect(mockVerify).toHaveBeenCalledTimes(message.certificates.length)
-    expect(mockDecryptFields).toHaveBeenCalledWith(verifierWallet)
-  })
+    expect(VerifiableCertificate).toHaveBeenCalledTimes(
+      message.certificates.length
+    );
+    expect(mockVerify).toHaveBeenCalledTimes(message.certificates.length);
+    expect(mockDecryptFields).toHaveBeenCalledWith(verifierWallet);
+  });
 
-  it('throws an error for mismatched identity key', async () => {
-    message.identityKey = 'different_subject'
+  it("throws an error for mismatched identity key", async () => {
+    message.identityKey = "different_subject";
 
     await expect(validateCertificates(verifierWallet, message)).rejects.toThrow(
       `The subject of one of your certificates ("valid_subject") is not the same as the request sender ("different_subject").`
-    )
-  })
+    );
+  });
 
-  it('throws an error if certificate signature is invalid', async () => {
-    mockVerify.mockResolvedValueOnce(false)
+  it("throws an error if certificate signature is invalid", async () => {
+    mockVerify.mockResolvedValueOnce(false);
 
     await expect(validateCertificates(verifierWallet, message)).rejects.toThrow(
       `The signature for the certificate with serial number valid_serial is invalid!`
-    )
-  })
+    );
+  });
 
-  it('throws an error for unrequested certifier', async () => {
+  it("throws an error for unrequested certifier", async () => {
     const certificatesRequested = {
-      certifiers: ['another_certifier'],
-      types: { requested_type: ['field1'] },
-    }
+      certifiers: ["another_certifier"],
+      types: { requested_type: ["field1"] },
+    };
 
     await expect(
       validateCertificates(verifierWallet, message, certificatesRequested)
     ).rejects.toThrow(
       `Certificate with serial number valid_serial has an unrequested certifier: valid_certifier`
-    )
-  })
+    );
+  });
 
-  it('throws an error for unrequested certificate type', async () => {
+  it("throws an error for unrequested certificate type", async () => {
     const certificatesRequested = {
-      certifiers: ['valid_certifier'],
-      types: { another_type: ['field1'] },
-    }
+      certifiers: ["valid_certifier"],
+      types: { another_type: ["field1"] },
+    };
 
     await expect(
       validateCertificates(verifierWallet, message, certificatesRequested)
-    ).rejects.toThrow(
-      `Certificate with type requested_type was not requested`
-    )
-  })
+    ).rejects.toThrow(`Certificate with type requested_type was not requested`);
+  });
 
-  it('decrypts fields without throwing errors', async () => {
-    await expect(validateCertificates(verifierWallet, message)).resolves.not.toThrow()
+  it("decrypts fields without throwing errors", async () => {
+    await expect(
+      validateCertificates(verifierWallet, message)
+    ).resolves.not.toThrow();
     for (const instance of mockInstances) {
-      expect(instance.decryptFields).toHaveBeenCalledWith(verifierWallet)
+      expect(instance.decryptFields).toHaveBeenCalledWith(verifierWallet);
     }
-  })
+  });
 
-  it('throws an error if a field decryption fails', async () => {
-    mockDecryptFields.mockRejectedValue(new Error('Decryption failed'))
-    await expect(validateCertificates(verifierWallet, message)).rejects.toThrow('Decryption failed')
-  })
+  it("throws an error if a field decryption fails", async () => {
+    mockDecryptFields.mockRejectedValue(new Error("Decryption failed"));
+    await expect(validateCertificates(verifierWallet, message)).rejects.toThrow(
+      "Decryption failed"
+    );
+  });
 
-  it('handles multiple certificates properly', async () => {
+  it("handles multiple certificates properly", async () => {
     const anotherCertificate = {
-      type: 'requested_type',
-      serialNumber: 'another_serial',
-      subject: 'valid_subject',
-      certifier: 'valid_certifier',
-      revocationOutpoint: 'outpoint',
-      fields: { field1: 'encryptedData1' },
+      type: "requested_type",
+      serialNumber: "another_serial",
+      subject: "valid_subject",
+      certifier: "valid_certifier",
+      revocationOutpoint: "outpoint",
+      fields: { field1: "encryptedData1" },
       decryptedFields: {},
-    }
+    };
 
-    message.certificates.push(anotherCertificate)
+    message.certificates.push(anotherCertificate);
 
-    await expect(validateCertificates(verifierWallet, message)).resolves.not.toThrow()
+    await expect(
+      validateCertificates(verifierWallet, message)
+    ).resolves.not.toThrow();
 
-    expect(VerifiableCertificate).toHaveBeenCalledTimes(2)
-    expect(mockVerify).toHaveBeenCalledTimes(2)
+    expect(VerifiableCertificate).toHaveBeenCalledTimes(2);
+    expect(mockVerify).toHaveBeenCalledTimes(2);
     for (const instance of mockInstances) {
-      expect(instance.decryptFields).toHaveBeenCalledWith(verifierWallet)
+      expect(instance.decryptFields).toHaveBeenCalledWith(verifierWallet);
     }
-  })
-})
+  });
+});

package/src/auth/utils/createNonce.ts

@@ -1,4 +1,9 @@
-import { Utils, Random, WalletInterface, WalletCounterparty } from '../../../mod.js'
+import {
+  Utils,
+  Random,
+  WalletInterface,
+  WalletCounterparty
+} from '../../../mod'
 
 /**
  * Creates a nonce derived from a wallet
@@ -6,7 +11,10 @@ import { Utils, Random, WalletInterface, WalletCounterparty } from '../../../mod
  * @param counterparty - The counterparty to the nonce creation. Defaults to 'self'.
  * @returns A random nonce derived with a wallet
  */
-export async function createNonce(wallet: WalletInterface, counterparty: WalletCounterparty = 'self'): Promise<string> {
+export async function createNonce(
+  wallet: WalletInterface,
+  counterparty: WalletCounterparty = 'self'
+): Promise<string> {
   // Generate 16 random bytes for the first half of the data
   const firstHalf = Random(16)
   // Create an sha256 HMAC
@@ -19,4 +27,4 @@ export async function createNonce(wallet: WalletInterface, counterparty: WalletC
   // Concatenate firstHalf and secondHalf as the nonce bytes
   const nonceBytes = [...firstHalf, ...hmac]
   return Utils.toBase64(nonceBytes)
-}
+}

package/src/auth/utils/getVerifiableCertificates.ts

@@ -1,6 +1,6 @@
-import { VerifiableCertificate } from "../certificates/VerifiableCertificate.js"
-import { WalletInterface } from "../../../mod.js"
-import { RequestedCertificateSet } from "../types.js"
+import { VerifiableCertificate } from '../certificates/VerifiableCertificate'
+import { WalletInterface } from '../../../mod'
+import { RequestedCertificateSet } from '../types'
 
 /**
  * Retrieves an array of verifiable certificates based on the request.
@@ -10,7 +10,11 @@ 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: WalletInterface, 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({
@@ -36,5 +40,6 @@ export const getVerifiableCertificates = async (wallet: WalletInterface, request
         keyringForVerifier,
         certificate.signature
       )
-    }))
-}
+    })
+  )
+}

package/src/auth/utils/index.ts

@@ -1,4 +1,4 @@
-export * from './verifyNonce.js'
-export * from './createNonce.js'
-export * from './getVerifiableCertificates.js'
-export * from './validateCertificates.js'
+export * from "./verifyNonce";
+export * from "./createNonce";
+export * from "./getVerifiableCertificates";
+export * from "./validateCertificates";

package/src/auth/utils/validateCertificates.ts

@@ -1,6 +1,6 @@
-import { WalletInterface } from "../../wallet/index.js"
-import { AuthMessage, RequestedCertificateSet } from "../types.js"
-import { VerifiableCertificate } from "../certificates/VerifiableCertificate.js"
+import { WalletInterface } from '../../wallet/index'
+import { AuthMessage, RequestedCertificateSet } from '../types'
+import { VerifiableCertificate } from '../certificates/VerifiableCertificate'
 
 /**
  * Validates and processes the certificates received from a peer.
@@ -10,45 +10,59 @@ 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: 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}").`)
-    }
+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}").`
+        )
+      }
 
-    // Verify Certificate structure and signature
-    const certToVerify = new VerifiableCertificate(
-      incomingCert.type,
-      incomingCert.serialNumber,
-      incomingCert.subject,
-      incomingCert.certifier,
-      incomingCert.revocationOutpoint,
-      incomingCert.fields,
-      incomingCert.keyring,
-      incomingCert.signature
-    )
-    const isValidCert = await certToVerify.verify()
-    if (!isValidCert) {
-      throw new Error(`The signature for the certificate with serial number ${certToVerify.serialNumber} is invalid!`)
-    }
+      // Verify Certificate structure and signature
+      const certToVerify = new VerifiableCertificate(
+        incomingCert.type,
+        incomingCert.serialNumber,
+        incomingCert.subject,
+        incomingCert.certifier,
+        incomingCert.revocationOutpoint,
+        incomingCert.fields,
+        incomingCert.keyring,
+        incomingCert.signature
+      )
+      const isValidCert = await certToVerify.verify()
+      if (!isValidCert) {
+        throw new Error(
+          `The signature for the certificate with serial number ${certToVerify.serialNumber} is invalid!`
+        )
+      }
 
-    // Check if the certificate matches requested certifiers, types, and fields
-    if (certificatesRequested) {
-      const { certifiers, types } = certificatesRequested
+      // Check if the certificate matches requested certifiers, types, and fields
+      if (certificatesRequested) {
+        const { certifiers, types } = certificatesRequested
 
-      // Check certifier matches
-      if (!certifiers.includes(certToVerify.certifier)) {
-        throw new Error(`Certificate with serial number ${certToVerify.serialNumber} has an unrequested certifier: ${certToVerify.certifier}`)
-      }
+        // Check certifier matches
+        if (!certifiers.includes(certToVerify.certifier)) {
+          throw new Error(
+            `Certificate with serial number ${certToVerify.serialNumber} has an unrequested certifier: ${certToVerify.certifier}`
+          )
+        }
 
-      // Check type and fields match requested
-      const requestedFields = types[certToVerify.type]
-      if (!requestedFields) {
-        throw new Error(`Certificate with type ${certToVerify.type} was not requested`)
+        // Check type and fields match requested
+        const requestedFields = types[certToVerify.type]
+        if (!requestedFields) {
+          throw new Error(
+            `Certificate with type ${certToVerify.type} was not requested`
+          )
+        }
       }
-    }
 
-    // Attempt to decrypt fields
-    await certToVerify.decryptFields(verifierWallet)
-  }))
-}
+      // Attempt to decrypt fields
+      await certToVerify.decryptFields(verifierWallet)
+    })
+  )
+}

package/src/auth/utils/verifyNonce.ts

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

package/src/compat/BSM.ts

@@ -1,10 +1,10 @@
-import BigNumber from '../primitives/BigNumber.js'
-import { Writer, toArray } from '../primitives/utils.js'
-import * as ECDSA from '../primitives/ECDSA.js'
-import * as Hash from '../primitives/Hash.js'
-import PrivateKey from '../primitives/PrivateKey.js'
-import PublicKey from '../primitives/PublicKey.js'
-import Signature from '../primitives/Signature.js'
+import BigNumber from '../primitives/BigNumber'
+import { Writer, toArray } from '../primitives/utils'
+import * as ECDSA from '../primitives/ECDSA'
+import * as Hash from '../primitives/Hash'
+import PrivateKey from '../primitives/PrivateKey'
+import PublicKey from '../primitives/PublicKey'
+import Signature from '../primitives/Signature'
 
 const prefix = 'Bitcoin Signed Message:\n'
 
@@ -33,7 +33,11 @@ export const magicHash = (messageBuf: number[]): number[] => {
  * @param mode The mode of operation. When "base64", the BSM format signature is returned. When "raw", a Signature object is returned. Default: "base64".
  * @returns The signature object when in raw mode, or the BSM base64 string when in base64 mode.
  */
-export const sign = (message: number[], privateKey: PrivateKey, mode: 'raw' | 'base64' = 'base64'): Signature | string => {
+export const sign = (
+  message: number[],
+  privateKey: PrivateKey,
+  mode: 'raw' | 'base64' = 'base64'
+): Signature | string => {
   const hashBuf = magicHash(message)
   const sig = ECDSA.sign(new BigNumber(hashBuf), privateKey, true)
   if (mode === 'raw') {
@@ -52,7 +56,11 @@ export const sign = (message: number[], privateKey: PrivateKey, mode: 'raw' | 'b
  * @param pubKey The public key for verification.
  * @returns True if the signature is valid, false otherwise.
  */
-export const verify = (message: number[], sig: Signature, pubKey: PublicKey): boolean => {
+export const verify = (
+  message: number[],
+  sig: Signature,
+  pubKey: PublicKey
+): boolean => {
   const hashBuf = magicHash(message)
   return ECDSA.verify(new BigNumber(hashBuf), sig, pubKey)
 }