@bsv/sdk 1.3.11 → 1.3.13

package/src/wallet/index.ts

@@ -1,8 +1,8 @@
-export * from './Wallet.interfaces.js'
-export * from './KeyDeriver.js'
-export { default as CachedKeyDeriver } from './CachedKeyDeriver.js'
-export { default as ProtoWallet } from './ProtoWallet.js'
-export { default as WalletClient } from './WalletClient.js'
-export { default as WalletErrors } from './WalletError.js'
-export * from './WalletError.js'
-export * from './substrates/index.js'
+export * from './Wallet.interfaces'
+export * from './KeyDeriver'
+export { default as CachedKeyDeriver } from './CachedKeyDeriver'
+export { default as ProtoWallet } from './ProtoWallet'
+export { default as WalletClient } from './WalletClient'
+export { default as WalletErrors } from './WalletError'
+export * from './WalletError'
+export * from './substrates/index'

package/src/wallet/substrates/HTTPWalletJSON.ts

@@ -1,4 +1,43 @@
-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'
+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'
 
 export default class HTTPWalletJSON implements WalletInterface {
   baseUrl: string
@@ -6,24 +45,30 @@ export default class HTTPWalletJSON implements WalletInterface {
   originator: OriginatorDomainNameStringUnder250Bytes | undefined
   api: (call: string, args: any) => Promise<any>
 
-  constructor(originator: OriginatorDomainNameStringUnder250Bytes | undefined, baseUrl: string = 'http://localhost:3321', httpClient = fetch) {
+  constructor(
+    originator: OriginatorDomainNameStringUnder250Bytes | undefined,
+    baseUrl: string = 'http://localhost:3321',
+    httpClient = fetch
+  ) {
     this.baseUrl = baseUrl
     this.originator = originator
     this.httpClient = httpClient
     this.api = async (call, args) => {
       try {
-        const response = await (await httpClient(`${this.baseUrl}/${call}`, {
-          method: 'POST',
-          headers: {
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-            'Originator': this.originator
-          },
-          body: JSON.stringify(args)
-        })).json()
+        const response = await (
+          await httpClient(`${this.baseUrl}/${call}`, {
+            method: 'POST',
+            headers: {
+              Accept: 'application/json',
+              'Content-Type': 'application/json',
+              Originator: this.originator
+            },
+            body: JSON.stringify(args)
+          })
+        ).json()
         return response
       } catch (error) {
-        console.log({ 'HTTPWalletJSON': { call, args, error } })
+        console.log({ HTTPWalletJSON: { call, args, error } })
         throw error
       }
     }
@@ -37,7 +82,9 @@ export default class HTTPWalletJSON implements WalletInterface {
     return await this.api('signAction', args)
   }
 
-  async abortAction(args: { reference: Base64String }): Promise<{ aborted: true }> {
+  async abortAction(args: {
+    reference: Base64String
+  }): Promise<{ aborted: true }> {
     return await this.api('abortAction', args)
   }
 
@@ -45,7 +92,9 @@ export default class HTTPWalletJSON implements WalletInterface {
     return await this.api('listActions', args)
   }
 
-  async internalizeAction(args: InternalizeActionArgs): Promise<{ accepted: true }> {
+  async internalizeAction(
+    args: InternalizeActionArgs
+  ): Promise<{ accepted: true }> {
     return await this.api('internalizeAction', args)
   }
 
@@ -53,67 +102,185 @@ export default class HTTPWalletJSON implements WalletInterface {
     return await this.api('listOutputs', args)
   }
 
-  async relinquishOutput(args: { basket: BasketStringUnder300Bytes, output: OutpointString }): Promise<{ relinquished: true }> {
+  async relinquishOutput(args: {
+    basket: BasketStringUnder300Bytes
+    output: OutpointString
+  }): Promise<{ relinquished: true }> {
     return await this.api('relinquishOutput', args)
   }
 
-  async getPublicKey(args: { seekPermission?: BooleanDefaultTrue, identityKey?: true, protocolID?: [SecurityLevel, ProtocolString5To400Bytes], keyID?: KeyIDStringUnder800Bytes, privileged?: BooleanDefaultFalse, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', forSelf?: BooleanDefaultFalse }): Promise<{ publicKey: PubKeyHex }> {
+  async getPublicKey(args: {
+    seekPermission?: BooleanDefaultTrue
+    identityKey?: true
+    protocolID?: [SecurityLevel, ProtocolString5To400Bytes]
+    keyID?: KeyIDStringUnder800Bytes
+    privileged?: BooleanDefaultFalse
+    privilegedReason?: DescriptionString5to50Bytes
+    counterparty?: PubKeyHex | 'self' | 'anyone'
+    forSelf?: BooleanDefaultFalse
+  }): Promise<{ publicKey: PubKeyHex }> {
     return await this.api('getPublicKey', args)
   }
 
-  async revealCounterpartyKeyLinkage(args: { counterparty: PubKeyHex, verifier: PubKeyHex, privilegedReason?: DescriptionString5to50Bytes, privileged?: BooleanDefaultFalse }): Promise<{ prover: PubKeyHex, verifier: PubKeyHex, counterparty: PubKeyHex, revelationTime: ISOTimestampString, encryptedLinkage: Byte[], encryptedLinkageProof: number[] }> {
+  async revealCounterpartyKeyLinkage(args: {
+    counterparty: PubKeyHex
+    verifier: PubKeyHex
+    privilegedReason?: DescriptionString5to50Bytes
+    privileged?: BooleanDefaultFalse
+  }): Promise<{
+    prover: PubKeyHex
+    verifier: PubKeyHex
+    counterparty: PubKeyHex
+    revelationTime: ISOTimestampString
+    encryptedLinkage: Byte[]
+    encryptedLinkageProof: number[]
+  }> {
     return await this.api('revealCounterpartyKeyLinkage', args)
   }
 
-  async revealSpecificKeyLinkage(args: { counterparty: PubKeyHex, verifier: PubKeyHex, protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, privileged?: BooleanDefaultFalse }): Promise<{ prover: PubKeyHex, verifier: PubKeyHex, counterparty: PubKeyHex, protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, encryptedLinkage: Byte[], encryptedLinkageProof: Byte[], proofType: Byte }> {
+  async revealSpecificKeyLinkage(args: {
+    counterparty: PubKeyHex
+    verifier: PubKeyHex
+    protocolID: [SecurityLevel, ProtocolString5To400Bytes]
+    keyID: KeyIDStringUnder800Bytes
+    privilegedReason?: DescriptionString5to50Bytes
+    privileged?: BooleanDefaultFalse
+  }): Promise<{
+    prover: PubKeyHex
+    verifier: PubKeyHex
+    counterparty: PubKeyHex
+    protocolID: [SecurityLevel, ProtocolString5To400Bytes]
+    keyID: KeyIDStringUnder800Bytes
+    encryptedLinkage: Byte[]
+    encryptedLinkageProof: Byte[]
+    proofType: Byte
+  }> {
     return await this.api('revealSpecificKeyLinkage', args)
   }
 
-  async encrypt(args: { seekPermission?: BooleanDefaultTrue, plaintext: Byte[], protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }): Promise<{ ciphertext: Byte[] }> {
+  async encrypt(args: {
+    seekPermission?: BooleanDefaultTrue
+    plaintext: Byte[]
+    protocolID: [SecurityLevel, ProtocolString5To400Bytes]
+    keyID: KeyIDStringUnder800Bytes
+    privilegedReason?: DescriptionString5to50Bytes
+    counterparty?: PubKeyHex | 'self' | 'anyone'
+    privileged?: BooleanDefaultFalse
+  }): Promise<{ ciphertext: Byte[] }> {
     return await this.api('encrypt', args)
   }
 
-  async decrypt(args: { seekPermission?: BooleanDefaultTrue, ciphertext: Byte[], protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }): Promise<{ plaintext: Byte[] }> {
+  async decrypt(args: {
+    seekPermission?: BooleanDefaultTrue
+    ciphertext: Byte[]
+    protocolID: [SecurityLevel, ProtocolString5To400Bytes]
+    keyID: KeyIDStringUnder800Bytes
+    privilegedReason?: DescriptionString5to50Bytes
+    counterparty?: PubKeyHex | 'self' | 'anyone'
+    privileged?: BooleanDefaultFalse
+  }): Promise<{ plaintext: Byte[] }> {
     return await this.api('decrypt', args)
   }
 
-  async createHmac(args: { seekPermission?: BooleanDefaultTrue, data: Byte[], protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }): Promise<{ hmac: Byte[] }> {
+  async createHmac(args: {
+    seekPermission?: BooleanDefaultTrue
+    data: Byte[]
+    protocolID: [SecurityLevel, ProtocolString5To400Bytes]
+    keyID: KeyIDStringUnder800Bytes
+    privilegedReason?: DescriptionString5to50Bytes
+    counterparty?: PubKeyHex | 'self' | 'anyone'
+    privileged?: BooleanDefaultFalse
+  }): Promise<{ hmac: Byte[] }> {
     return await this.api('createHmac', args)
   }
 
-  async verifyHmac(args: { seekPermission?: BooleanDefaultTrue, data: Byte[], hmac: Byte[], protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }): Promise<{ valid: true }> {
+  async verifyHmac(args: {
+    seekPermission?: BooleanDefaultTrue
+    data: Byte[]
+    hmac: Byte[]
+    protocolID: [SecurityLevel, ProtocolString5To400Bytes]
+    keyID: KeyIDStringUnder800Bytes
+    privilegedReason?: DescriptionString5to50Bytes
+    counterparty?: PubKeyHex | 'self' | 'anyone'
+    privileged?: BooleanDefaultFalse
+  }): Promise<{ valid: true }> {
     return await this.api('verifyHmac', args)
   }
 
-  async createSignature(args: { seekPermission?: BooleanDefaultTrue, data?: Byte[], hashToDirectlySign?: Byte[], protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }): Promise<{ signature: Byte[] }> {
+  async createSignature(args: {
+    seekPermission?: BooleanDefaultTrue
+    data?: Byte[]
+    hashToDirectlySign?: Byte[]
+    protocolID: [SecurityLevel, ProtocolString5To400Bytes]
+    keyID: KeyIDStringUnder800Bytes
+    privilegedReason?: DescriptionString5to50Bytes
+    counterparty?: PubKeyHex | 'self' | 'anyone'
+    privileged?: BooleanDefaultFalse
+  }): Promise<{ signature: Byte[] }> {
     return await this.api('createSignature', args)
   }
 
-  async verifySignature(args: { seekPermission?: BooleanDefaultTrue, data?: Byte[], hashToDirectlyVerify?: Byte[], signature: Byte[], protocolID: [SecurityLevel, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', forSelf?: BooleanDefaultFalse, privileged?: BooleanDefaultFalse }): Promise<{ valid: true }> {
+  async verifySignature(args: {
+    seekPermission?: BooleanDefaultTrue
+    data?: Byte[]
+    hashToDirectlyVerify?: Byte[]
+    signature: Byte[]
+    protocolID: [SecurityLevel, ProtocolString5To400Bytes]
+    keyID: KeyIDStringUnder800Bytes
+    privilegedReason?: DescriptionString5to50Bytes
+    counterparty?: PubKeyHex | 'self' | 'anyone'
+    forSelf?: BooleanDefaultFalse
+    privileged?: BooleanDefaultFalse
+  }): Promise<{ valid: true }> {
     return await this.api('verifySignature', args)
   }
 
-  async acquireCertificate(args: AcquireCertificateArgs): Promise<AcquireCertificateResult> {
+  async acquireCertificate(
+    args: AcquireCertificateArgs
+  ): Promise<AcquireCertificateResult> {
     return await this.api('acquireCertificate', args)
   }
 
-  async listCertificates(args: { certifiers: PubKeyHex[], types: Base64String[], limit?: PositiveIntegerDefault10Max10000, offset?: PositiveIntegerOrZero, privileged?: BooleanDefaultFalse, privilegedReason?: DescriptionString5to50Bytes }): Promise<ListCertificatesResult> {
+  async listCertificates(args: {
+    certifiers: PubKeyHex[]
+    types: Base64String[]
+    limit?: PositiveIntegerDefault10Max10000
+    offset?: PositiveIntegerOrZero
+    privileged?: BooleanDefaultFalse
+    privilegedReason?: DescriptionString5to50Bytes
+  }): Promise<ListCertificatesResult> {
     return await this.api('listCertificates', args)
   }
 
-  async proveCertificate(args: ProveCertificateArgs): Promise<ProveCertificateResult> {
+  async proveCertificate(
+    args: ProveCertificateArgs
+  ): Promise<ProveCertificateResult> {
     return await this.api('proveCertificate', args)
   }
 
-  async relinquishCertificate(args: { type: Base64String, serialNumber: Base64String, certifier: PubKeyHex }): Promise<{ relinquished: true }> {
+  async relinquishCertificate(args: {
+    type: Base64String
+    serialNumber: Base64String
+    certifier: PubKeyHex
+  }): Promise<{ relinquished: true }> {
     return await this.api('relinquishCertificate', args)
   }
 
-  async discoverByIdentityKey(args: { seekPermission?: BooleanDefaultTrue, identityKey: PubKeyHex, limit?: PositiveIntegerDefault10Max10000, offset?: PositiveIntegerOrZero }): Promise<DiscoverCertificatesResult> {
+  async discoverByIdentityKey(args: {
+    seekPermission?: BooleanDefaultTrue
+    identityKey: PubKeyHex
+    limit?: PositiveIntegerDefault10Max10000
+    offset?: PositiveIntegerOrZero
+  }): Promise<DiscoverCertificatesResult> {
     return await this.api('discoverByIdentityKey', args)
   }
 
-  async discoverByAttributes(args: { seekPermission?: BooleanDefaultTrue, attributes: Record<CertificateFieldNameUnder50Bytes, string>, limit?: PositiveIntegerDefault10Max10000, offset?: PositiveIntegerOrZero }): Promise<DiscoverCertificatesResult> {
+  async discoverByAttributes(args: {
+    seekPermission?: BooleanDefaultTrue
+    attributes: Record<CertificateFieldNameUnder50Bytes, string>
+    limit?: PositiveIntegerDefault10Max10000
+    offset?: PositiveIntegerOrZero
+  }): Promise<DiscoverCertificatesResult> {
     return await this.api('discoverByAttributes', args)
   }
 
@@ -129,7 +296,9 @@ export default class HTTPWalletJSON implements WalletInterface {
     return await this.api('getHeight', args)
   }
 
-  async getHeaderForHeight(args: { height: PositiveInteger }): Promise<{ header: HexString }> {
+  async getHeaderForHeight(args: {
+    height: PositiveInteger
+  }): Promise<{ header: HexString }> {
     return await this.api('getHeaderForHeight', args)
   }
 
@@ -140,4 +309,4 @@ export default class HTTPWalletJSON implements WalletInterface {
   async getVersion(args: {}): Promise<{ version: VersionString7To30Bytes }> {
     return await this.api('getVersion', args)
   }
-}
+}

package/src/wallet/substrates/HTTPWalletWire.ts

@@ -1,47 +1,51 @@
-import WalletWire from './WalletWire.js'
-import WalletWireCalls from './WalletWireCalls.js'
-import { Utils } from '../../primitives/index.js'
+import WalletWire from "./WalletWire";
+import WalletWireCalls from "./WalletWireCalls";
+import { Utils } from "../../primitives/index";
 
 export default class HTTPWalletWire implements WalletWire {
-  baseUrl: string
-  httpClient: typeof fetch
-  originator: string | undefined
+  baseUrl: string;
+  httpClient: typeof fetch;
+  originator: string | undefined;
 
-  constructor(originator: string | undefined, baseUrl: string = 'http://localhost:3301', httpClient = fetch) {
-    this.baseUrl = baseUrl
-    this.httpClient = httpClient
-    this.originator = originator
+  constructor(
+    originator: string | undefined,
+    baseUrl: string = "http://localhost:3301",
+    httpClient = fetch
+  ) {
+    this.baseUrl = baseUrl;
+    this.httpClient = httpClient;
+    this.originator = originator;
   }
 
   async transmitToWallet(message: number[]): Promise<number[]> {
-    const messageReader = new Utils.Reader(message)
+    const messageReader = new Utils.Reader(message);
     // Read call code
-    const callCode = messageReader.readUInt8()
+    const callCode = messageReader.readUInt8();
 
     // Map call code to call name
-    const callName = WalletWireCalls[callCode] // calls is enum
+    const callName = WalletWireCalls[callCode]; // calls is enum
     if (!callName) {
       // Invalid call code
-      throw new Error(`Invalid call code: ${callCode}`)
+      throw new Error(`Invalid call code: ${callCode}`);
     }
 
     // Read originator length
-    const originatorLength = messageReader.readUInt8()
-    let originator: string | undefined
+    const originatorLength = messageReader.readUInt8();
+    let originator: string | undefined;
     if (originatorLength > 0) {
-      const originatorBytes = messageReader.read(originatorLength)
-      originator = Utils.toUTF8(originatorBytes)
+      const originatorBytes = messageReader.read(originatorLength);
+      originator = Utils.toUTF8(originatorBytes);
     }
-    const payload = messageReader.read()
+    const payload = messageReader.read();
     const response = await fetch(`${this.baseUrl}/${callName}`, {
-      method: 'POST',
+      method: "POST",
       headers: {
-        'Content-Type': 'application/octet-stream',
-        Origin: originator
+        "Content-Type": "application/octet-stream",
+        Origin: originator,
       },
-      body: new Uint8Array(payload)
-    })
-    const responseBuffer = await response.arrayBuffer()
-    return Array.from(new Uint8Array(responseBuffer))
+      body: new Uint8Array(payload),
+    });
+    const responseBuffer = await response.arrayBuffer();
+    return Array.from(new Uint8Array(responseBuffer));
   }
 }

package/src/wallet/substrates/WalletWire.ts

@@ -2,5 +2,5 @@
  * A Wallet Wire is an abstraction over a raw transport medium where binary data can be sent to and subsequently received from a wallet.
  */
 export default interface WalletWire {
-  transmitToWallet: (message: number[]) => Promise<number[]>
+  transmitToWallet: (message: number[]) => Promise<number[]>;
 }

package/src/wallet/substrates/WalletWireCalls.ts

@@ -27,8 +27,8 @@ enum calls {
   getHeight = 25,
   getHeaderForHeight = 26,
   getNetwork = 27,
-  getVersion = 28
+  getVersion = 28,
 }
 
-export default calls
-export type CallType = keyof typeof calls
+export default calls;
+export type CallType = keyof typeof calls;