@bsv/sdk 1.3.12 → 1.3.14

package/src/wallet/substrates/HTTPWalletJSON.ts

@@ -1,143 +1,326 @@
-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,
+  HexString,
+  InternalizeActionArgs,
+  ISOTimestampString,
+  KeyIDStringUnder800Bytes,
+  ListActionsArgs,
+  ListActionsResult,
+  ListCertificatesResult,
+  ListOutputsArgs,
+  ListOutputsResult,
+  OutpointString,
+  PositiveInteger,
+  PositiveIntegerDefault10Max10000,
+  PositiveIntegerOrZero,
+  ProtocolString5To400Bytes,
+  ProveCertificateArgs,
+  ProveCertificateResult,
+  PubKeyHex,
+  SecurityLevel,
+  SignActionArgs,
+  SignActionResult,
+  VersionString7To30Bytes
+} from '../Wallet.interfaces.js'
 
 export default class HTTPWalletJSON implements WalletInterface {
   baseUrl: string
   httpClient: typeof fetch
   originator: OriginatorDomainNameStringUnder250Bytes | undefined
-  api: (call: string, args: any) => Promise<any>
+  api: (call: string, args: object) => Promise<unknown> // Fixed `any` types
 
-  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) => {
+
+    this.api = async (call: string, args: object) => {
       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 ?? '' // ✅ Fix: Explicitly handle nullish `originator`
+            },
+            body: JSON.stringify(args)
+          })
+        ).json()
         return response
       } catch (error) {
-        console.log({ 'HTTPWalletJSON': { call, args, error } })
+        console.log({ HTTPWalletJSON: { call, args, error } })
         throw error
       }
     }
   }
 
   async createAction(args: CreateActionArgs): Promise<CreateActionResult> {
-    return await this.api('createAction', args)
+    return await this.api('createAction', args) as CreateActionResult
   }
 
   async signAction(args: SignActionArgs): Promise<SignActionResult> {
-    return await this.api('signAction', args)
+    return await this.api('signAction', args) as SignActionResult
   }
 
-  async abortAction(args: { reference: Base64String }): Promise<{ aborted: true }> {
-    return await this.api('abortAction', args)
+  async abortAction(args: {
+    reference: Base64String
+  }): Promise<{ aborted: true }> {
+    return await this.api('abortAction', args) as { aborted: true }
   }
 
   async listActions(args: ListActionsArgs): Promise<ListActionsResult> {
-    return await this.api('listActions', args)
+    return await this.api('listActions', args) as ListActionsResult
   }
 
-  async internalizeAction(args: InternalizeActionArgs): Promise<{ accepted: true }> {
-    return await this.api('internalizeAction', args)
+  async internalizeAction(
+    args: InternalizeActionArgs
+  ): Promise<{ accepted: true }> {
+    return await this.api('internalizeAction', args) as { accepted: true }
   }
 
   async listOutputs(args: ListOutputsArgs): Promise<ListOutputsResult> {
-    return await this.api('listOutputs', args)
+    return await this.api('listOutputs', args) as ListOutputsResult
   }
 
-  async relinquishOutput(args: { basket: BasketStringUnder300Bytes, output: OutpointString }): Promise<{ relinquished: true }> {
-    return await this.api('relinquishOutput', args)
+  async relinquishOutput(args: {
+    basket: BasketStringUnder300Bytes
+    output: OutpointString
+  }): Promise<{ relinquished: true }> {
+    return await this.api('relinquishOutput', args) as { relinquished: true }
   }
 
-  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 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) as { publicKey: PubKeyHex }
   }
 
-  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 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) as {
+      prover: PubKeyHex
+      verifier: PubKeyHex
+      counterparty: PubKeyHex
+      revelationTime: ISOTimestampString
+      encryptedLinkage: Byte[]
+      encryptedLinkageProof: number[]
+    }
   }
 
-  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 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) as {
+      prover: PubKeyHex
+      verifier: PubKeyHex
+      counterparty: PubKeyHex
+      protocolID: [SecurityLevel, ProtocolString5To400Bytes]
+      keyID: KeyIDStringUnder800Bytes
+      encryptedLinkage: Byte[]
+      encryptedLinkageProof: Byte[]
+      proofType: 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 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) as { ciphertext: 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 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) as { plaintext: 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 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) as { hmac: Byte[] }
   }
 
-  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 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) as { valid: true }
   }
 
-  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 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) as { signature: Byte[] }
   }
 
-  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 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) as { valid: true }
   }
 
-  async acquireCertificate(args: AcquireCertificateArgs): Promise<AcquireCertificateResult> {
-    return await this.api('acquireCertificate', args)
+  async acquireCertificate(
+    args: AcquireCertificateArgs
+  ): Promise<AcquireCertificateResult> {
+    return await this.api('acquireCertificate', args) as AcquireCertificateResult
   }
 
-  async listCertificates(args: { certifiers: PubKeyHex[], types: Base64String[], limit?: PositiveIntegerDefault10Max10000, offset?: PositiveIntegerOrZero, privileged?: BooleanDefaultFalse, privilegedReason?: DescriptionString5to50Bytes }): Promise<ListCertificatesResult> {
-    return await this.api('listCertificates', args)
+  async listCertificates(args: {
+    certifiers: PubKeyHex[]
+    types: Base64String[]
+    limit?: PositiveIntegerDefault10Max10000
+    offset?: PositiveIntegerOrZero
+    privileged?: BooleanDefaultFalse
+    privilegedReason?: DescriptionString5to50Bytes
+  }): Promise<ListCertificatesResult> {
+    return await this.api('listCertificates', args) as ListCertificatesResult
   }
 
-  async proveCertificate(args: ProveCertificateArgs): Promise<ProveCertificateResult> {
-    return await this.api('proveCertificate', args)
+  async proveCertificate(
+    args: ProveCertificateArgs
+  ): Promise<ProveCertificateResult> {
+    return await this.api('proveCertificate', args) as ProveCertificateResult
   }
 
-  async relinquishCertificate(args: { type: Base64String, serialNumber: Base64String, certifier: PubKeyHex }): Promise<{ relinquished: true }> {
-    return await this.api('relinquishCertificate', args)
+  async relinquishCertificate(args: {
+    type: Base64String
+    serialNumber: Base64String
+    certifier: PubKeyHex
+  }): Promise<{ relinquished: true }> {
+    return await this.api('relinquishCertificate', args) as { relinquished: true }
   }
 
-  async discoverByIdentityKey(args: { seekPermission?: BooleanDefaultTrue, identityKey: PubKeyHex, limit?: PositiveIntegerDefault10Max10000, offset?: PositiveIntegerOrZero }): Promise<DiscoverCertificatesResult> {
-    return await this.api('discoverByIdentityKey', args)
+  async discoverByIdentityKey(args: {
+    seekPermission?: BooleanDefaultTrue
+    identityKey: PubKeyHex
+    limit?: PositiveIntegerDefault10Max10000
+    offset?: PositiveIntegerOrZero
+  }): Promise<DiscoverCertificatesResult> {
+    return await this.api('discoverByIdentityKey', args) as DiscoverCertificatesResult
   }
 
-  async discoverByAttributes(args: { seekPermission?: BooleanDefaultTrue, attributes: Record<CertificateFieldNameUnder50Bytes, string>, limit?: PositiveIntegerDefault10Max10000, offset?: PositiveIntegerOrZero }): Promise<DiscoverCertificatesResult> {
-    return await this.api('discoverByAttributes', args)
+  async discoverByAttributes(args: {
+    seekPermission?: BooleanDefaultTrue
+    attributes: Record<CertificateFieldNameUnder50Bytes, string>
+    limit?: PositiveIntegerDefault10Max10000
+    offset?: PositiveIntegerOrZero
+  }): Promise<DiscoverCertificatesResult> {
+    return await this.api('discoverByAttributes', args) as DiscoverCertificatesResult
   }
 
-  async isAuthenticated(args: {}): Promise<{ authenticated: true }> {
-    return await this.api('isAuthenticated', args)
+  async isAuthenticated(args: object): Promise<{ authenticated: true }> {
+    return await this.api('isAuthenticated', args) as { authenticated: true }
   }
 
-  async waitForAuthentication(args: {}): Promise<{ authenticated: true }> {
-    return await this.api('waitForAuthentication', args)
+  async waitForAuthentication(args: object): Promise<{ authenticated: true }> {
+    return await this.api('waitForAuthentication', args) as { authenticated: true }
   }
 
-  async getHeight(args: {}): Promise<{ height: PositiveInteger }> {
-    return await this.api('getHeight', args)
+  async getHeight(args: object): Promise<{ height: PositiveInteger }> {
+    return await this.api('getHeight', args) as { height: PositiveInteger }
   }
 
-  async getHeaderForHeight(args: { height: PositiveInteger }): Promise<{ header: HexString }> {
-    return await this.api('getHeaderForHeight', args)
+  async getHeaderForHeight(args: {
+    height: PositiveInteger
+  }): Promise<{ header: HexString }> {
+    return await this.api('getHeaderForHeight', args) as { header: HexString }
   }
 
-  async getNetwork(args: {}): Promise<{ network: 'mainnet' | 'testnet' }> {
-    return await this.api('getNetwork', args)
+  async getNetwork(args: object): Promise<{ network: 'mainnet' | 'testnet' }> {
+    return await this.api('getNetwork', args) as { network: 'mainnet' | 'testnet' }
   }
 
-  async getVersion(args: {}): Promise<{ version: VersionString7To30Bytes }> {
-    return await this.api('getVersion', args)
+  async getVersion(args: object): Promise<{ version: VersionString7To30Bytes }> {
+    return await this.api('getVersion', args) as { version: VersionString7To30Bytes }
   }
-}
+}

package/src/wallet/substrates/HTTPWalletWire.ts

@@ -7,7 +7,11 @@ export default class HTTPWalletWire implements WalletWire {
   httpClient: typeof fetch
   originator: string | undefined
 
-  constructor(originator: string | undefined, baseUrl: string = 'http://localhost:3301', httpClient = fetch) {
+  constructor(
+    originator: string | undefined,
+    baseUrl: string = 'http://localhost:3301',
+    httpClient = fetch
+  ) {
     this.baseUrl = baseUrl
     this.httpClient = httpClient
     this.originator = originator
@@ -20,7 +24,7 @@ export default class HTTPWalletWire implements WalletWire {
 
     // Map call code to call name
     const callName = WalletWireCalls[callCode] // calls is enum
-    if (!callName) {
+    if (callName === undefined || callName === '') {
       // Invalid call code
       throw new Error(`Invalid call code: ${callCode}`)
     }
@@ -37,7 +41,7 @@ export default class HTTPWalletWire implements WalletWire {
       method: 'POST',
       headers: {
         'Content-Type': 'application/octet-stream',
-        Origin: originator
+        Origin: originator ?? '' // ✅ Explicitly handle null/undefined cases
       },
       body: new Uint8Array(payload)
     })

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 type CallType = keyof typeof calls