@bsv/sdk 1.2.2 → 1.2.4

package/src/wallet/Wallet.interfaces.ts

@@ -203,9 +203,9 @@ export type ActionStatus = | 'completed' | 'unprocessed' | 'sending' | 'unproven
 
 /**
  * Controls behavior of input BEEF validation.
- * 
+ *
  * If `known`, input transactions may omit supporting validity proof data for all TXIDs known to this wallet.
- * 
+ *
  * If undefined, input BEEFs must be complete and valid.
  */
 export type TrustSelf = 'known'
@@ -279,7 +279,7 @@ export interface CreateActionResult {
   txid?: TXIDHexString
   tx?: AtomicBEEF
   noSendChange?: OutpointString[]
-  sendWithResults?: Array<SendWithResult>
+  sendWithResults?: SendWithResult[]
   signableTransaction?: SignableTransaction
 }
 
@@ -296,8 +296,8 @@ export interface CreateActionResult {
 export interface CreateActionArgs {
   description: DescriptionString5to50Bytes
   inputBEEF?: BEEF
-  inputs?: Array<CreateActionInput>
-  outputs?: Array<CreateActionOutput>
+  inputs?: CreateActionInput[]
+  outputs?: CreateActionOutput[]
   lockTime?: PositiveIntegerOrZero
   version?: PositiveIntegerOrZero
   labels?: LabelStringUnder300Bytes[]
@@ -340,12 +340,12 @@ export interface SignActionArgs {
 }
 
 /**
- * 
+ *
  */
 export interface SignActionResult {
   txid?: TXIDHexString
   tx?: AtomicBEEF
-  sendWithResults?: Array<SendWithResult>
+  sendWithResults?: SendWithResult[]
 }
 
 /**
@@ -431,13 +431,13 @@ export interface WalletAction {
   labels?: LabelStringUnder300Bytes[]
   version: PositiveIntegerOrZero
   lockTime: PositiveIntegerOrZero
-  inputs?: Array<WalletActionInput>
-  outputs?: Array<WalletActionOutput>
+  inputs?: WalletActionInput[]
+  outputs?: WalletActionOutput[]
 }
 
 export interface ListActionsResult {
   totalActions: PositiveIntegerOrZero
-  actions: Array<WalletAction>
+  actions: WalletAction[]
 }
 
 /**
@@ -484,7 +484,7 @@ export interface InternalizeOutput {
  */
 export interface InternalizeActionArgs {
   tx: AtomicBEEF
-  outputs: Array<InternalizeOutput>
+  outputs: InternalizeOutput[]
   description: DescriptionString5to50Bytes
   labels?: LabelStringUnder300Bytes[]
   seekPermission?: BooleanDefaultTrue
@@ -523,7 +523,7 @@ export interface ListOutputsArgs {
 export interface ListOutputsResult {
   totalOutputs: PositiveIntegerOrZero
   BEEF?: BEEF
-  outputs: Array<WalletOutput>
+  outputs: WalletOutput[]
 }
 
 /**
@@ -550,9 +550,9 @@ export interface WalletEncryptionArgs extends KeyLinkageArgs {
 
 /**
    * When `identityKey` is true, `WalletEncryptionArgs` are not used.
-   * 
+   *
    * When `identityKey` is undefined, `WalletEncryptionArgs` are required.
-   * 
+   *
    * @param {BooleanDefaultFalse|true} [identityKey] - Use true to retrieve the current user's own identity key, overriding any protocol ID, key ID, or counterparty specified.
    * @param {BooleanDefaultFalse} [forSelf] - Whether to return the public key derived from the current user's own identity (as opposed to the counterparty's identity).
  */
@@ -736,7 +736,7 @@ export interface ListCertificatesArgs {
 
 export interface ListCertificatesResult {
   totalCertificates: PositiveIntegerOrZero
-  certificates: Array<WalletCertificate>
+  certificates: WalletCertificate[]
 }
 
 /**
@@ -786,7 +786,7 @@ export interface DiscoverByIdentityKeyArgs {
  */
 export interface DiscoverCertificatesResult {
   totalCertificates: PositiveIntegerOrZero
-  certificates: Array<IdentityCertificate>
+  certificates: IdentityCertificate[]
 }
 
 /**
@@ -817,9 +817,9 @@ export interface WalletErrorObject extends Error {
  * encryption, decryption, identity certificate management, identity verification, and communication
  * with applications as per the BRC standards. This interface allows applications to interact with
  * the wallet for a range of functionalities aligned with the Babbage architectural principles.
- * 
+ *
  * Error Handling
- * 
+ *
  * Every method of the `Wallet` interface has a return value of the form `Promise<object>`.
  * When an error occurs, an exception object may be thrown which must conform to the `WalletError` interface.
  * Serialization layers can rely on the `isError` property being unique to error objects to
@@ -1167,4 +1167,4 @@ export interface Wallet {
     args: {},
     originator?: OriginatorDomainNameStringUnder250Bytes
   ) => Promise<{ version: VersionString7To30Bytes }>
-}
+}

package/src/wallet/WalletClient.ts

@@ -12,7 +12,7 @@ const MAX_XDM_RESPONSE_WAIT = 200
 export default class WalletClient implements Wallet {
   public substrate: 'auto' | Wallet
   originator?: OriginatorDomainNameStringUnder250Bytes
-  constructor(substrate: 'auto' | 'Cicada' | 'XDM' | 'window.CWI' | Wallet = 'auto', originator?: OriginatorDomainNameStringUnder250Bytes) {
+  constructor (substrate: 'auto' | 'Cicada' | 'XDM' | 'window.CWI' | Wallet = 'auto', originator?: OriginatorDomainNameStringUnder250Bytes) {
     if (substrate === 'Cicada') substrate = new WalletWireTransceiver(new HTTPWalletWire(originator))
     if (substrate === 'window.CWI') substrate = new WindowCWISubstrate()
     if (substrate === 'XDM') substrate = new XDMSubstrate()
@@ -20,7 +20,7 @@ export default class WalletClient implements Wallet {
     this.originator = originator
   }
 
-  async connectToSubstrate() {
+  async connectToSubstrate () {
     if (typeof this.substrate === 'object') {
       return // substrate is already connected
     }
@@ -60,141 +60,141 @@ export default class WalletClient implements Wallet {
     }
   }
 
-  async createAction(args: CreateActionArgs): Promise<CreateActionResult> {
+  async createAction (args: CreateActionArgs): Promise<CreateActionResult> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).createAction(args, this.originator)
   }
 
-  async signAction(args: SignActionArgs): Promise<SignActionResult> {
+  async signAction (args: SignActionArgs): Promise<SignActionResult> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).signAction(args, this.originator)
   }
 
-  async abortAction(args: { reference: Base64String }): Promise<{ aborted: true }> {
+  async abortAction (args: { reference: Base64String }): Promise<{ aborted: true }> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).abortAction(args, this.originator)
   }
 
-  async listActions(args: ListActionsArgs): Promise<ListActionsResult> {
+  async listActions (args: ListActionsArgs): Promise<ListActionsResult> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).listActions(args, this.originator)
   }
 
-  async internalizeAction(args: InternalizeActionArgs): Promise<{ accepted: true }> {
+  async internalizeAction (args: InternalizeActionArgs): Promise<{ accepted: true }> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).internalizeAction(args, this.originator)
   }
 
-  async listOutputs(args: ListOutputsArgs): Promise<ListOutputsResult> {
+  async listOutputs (args: ListOutputsArgs): Promise<ListOutputsResult> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).listOutputs(args, this.originator)
   }
 
-  async relinquishOutput(args: { basket: BasketStringUnder300Bytes, output: OutpointString }): Promise<{ relinquished: true }> {
+  async relinquishOutput (args: { basket: BasketStringUnder300Bytes, output: OutpointString }): Promise<{ relinquished: true }> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).relinquishOutput(args, this.originator)
   }
 
-  async getPublicKey(args: { identityKey?: true, protocolID?: [0 | 1 | 2, ProtocolString5To400Bytes], keyID?: KeyIDStringUnder800Bytes, privileged?: BooleanDefaultFalse, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', forSelf?: BooleanDefaultFalse }): Promise<{ publicKey: PubKeyHex }> {
+  async getPublicKey (args: { identityKey?: true, protocolID?: [0 | 1 | 2, ProtocolString5To400Bytes], keyID?: KeyIDStringUnder800Bytes, privileged?: BooleanDefaultFalse, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', forSelf?: BooleanDefaultFalse }): Promise<{ publicKey: PubKeyHex }> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).getPublicKey(args, this.originator)
   }
 
-  async revealCounterpartyKeyLinkage(args: { counterparty: PubKeyHex, verifier: PubKeyHex, privilegedReason?: DescriptionString5to50Bytes, privileged?: BooleanDefaultFalse }): Promise<{ prover: PubKeyHex, verifier: PubKeyHex, counterparty: PubKeyHex, revelationTime: ISOTimestampString, encryptedLinkage: Byte[], encryptedLinkageProof: Byte[] }> {
+  async revealCounterpartyKeyLinkage (args: { counterparty: PubKeyHex, verifier: PubKeyHex, privilegedReason?: DescriptionString5to50Bytes, privileged?: BooleanDefaultFalse }): Promise<{ prover: PubKeyHex, verifier: PubKeyHex, counterparty: PubKeyHex, revelationTime: ISOTimestampString, encryptedLinkage: Byte[], encryptedLinkageProof: Byte[] }> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).revealCounterpartyKeyLinkage(args, this.originator)
   }
 
-  async revealSpecificKeyLinkage(args: { counterparty: PubKeyHex, verifier: PubKeyHex, protocolID: [0 | 1 | 2, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, privileged?: BooleanDefaultFalse }): Promise<{ prover: PubKeyHex, verifier: PubKeyHex, counterparty: PubKeyHex, protocolID: [0 | 1 | 2, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, encryptedLinkage: Byte[], encryptedLinkageProof: Byte[], proofType: Byte }> {
+  async revealSpecificKeyLinkage (args: { counterparty: PubKeyHex, verifier: PubKeyHex, protocolID: [0 | 1 | 2, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, privileged?: BooleanDefaultFalse }): Promise<{ prover: PubKeyHex, verifier: PubKeyHex, counterparty: PubKeyHex, protocolID: [0 | 1 | 2, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, encryptedLinkage: Byte[], encryptedLinkageProof: Byte[], proofType: Byte }> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).revealSpecificKeyLinkage(args, this.originator)
   }
 
-  async encrypt(args: { plaintext: Byte[], protocolID: [0 | 1 | 2, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }): Promise<{ ciphertext: Byte[] }> {
+  async encrypt (args: { plaintext: Byte[], protocolID: [0 | 1 | 2, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }): Promise<{ ciphertext: Byte[] }> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).encrypt(args, this.originator)
   }
 
-  async decrypt(args: { ciphertext: Byte[], protocolID: [0 | 1 | 2, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }): Promise<{ plaintext: Byte[] }> {
+  async decrypt (args: { ciphertext: Byte[], protocolID: [0 | 1 | 2, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }): Promise<{ plaintext: Byte[] }> {
     return await (this.substrate as Wallet).decrypt(args, this.originator)
   }
 
-  async createHmac(args: { data: Byte[], protocolID: [0 | 1 | 2, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }): Promise<{ hmac: Byte[] }> {
+  async createHmac (args: { data: Byte[], protocolID: [0 | 1 | 2, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }): Promise<{ hmac: Byte[] }> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).createHmac(args, this.originator)
   }
 
-  async verifyHmac(args: { data: Byte[], hmac: Byte[], protocolID: [0 | 1 | 2, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }): Promise<{ valid: true }> {
+  async verifyHmac (args: { data: Byte[], hmac: Byte[], protocolID: [0 | 1 | 2, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }): Promise<{ valid: true }> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).verifyHmac(args, this.originator)
   }
 
-  async createSignature(args: { data?: Byte[], hashToDirectlySign?: Byte[], protocolID: [0 | 1 | 2, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }): Promise<{ signature: Byte[] }> {
+  async createSignature (args: { data?: Byte[], hashToDirectlySign?: Byte[], protocolID: [0 | 1 | 2, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', privileged?: BooleanDefaultFalse }): Promise<{ signature: Byte[] }> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).createSignature(args, this.originator)
   }
 
-  async verifySignature(args: { data?: Byte[], hashToDirectlyVerify?: Byte[], signature: Byte[], protocolID: [0 | 1 | 2, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', forSelf?: BooleanDefaultFalse, privileged?: BooleanDefaultFalse }): Promise<{ valid: true }> {
+  async verifySignature (args: { data?: Byte[], hashToDirectlyVerify?: Byte[], signature: Byte[], protocolID: [0 | 1 | 2, ProtocolString5To400Bytes], keyID: KeyIDStringUnder800Bytes, privilegedReason?: DescriptionString5to50Bytes, counterparty?: PubKeyHex | 'self' | 'anyone', forSelf?: BooleanDefaultFalse, privileged?: BooleanDefaultFalse }): Promise<{ valid: true }> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).verifySignature(args, this.originator)
   }
 
-  async acquireCertificate(args: AcquireCertificateArgs): Promise<AcquireCertificateResult> {
+  async acquireCertificate (args: AcquireCertificateArgs): Promise<AcquireCertificateResult> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).acquireCertificate(args, this.originator)
   }
 
-  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> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).listCertificates(args, this.originator)
   }
 
-  async proveCertificate(args: ProveCertificateArgs): Promise<ProveCertificateResult> {
+  async proveCertificate (args: ProveCertificateArgs): Promise<ProveCertificateResult> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).proveCertificate(args, this.originator)
   }
 
-  async relinquishCertificate(args: { type: Base64String, serialNumber: Base64String, certifier: PubKeyHex }): Promise<{ relinquished: true }> {
+  async relinquishCertificate (args: { type: Base64String, serialNumber: Base64String, certifier: PubKeyHex }): Promise<{ relinquished: true }> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).relinquishCertificate(args, this.originator)
   }
 
-  async discoverByIdentityKey(args: { identityKey: PubKeyHex, limit?: PositiveIntegerDefault10Max10000, offset?: PositiveIntegerOrZero }): Promise<DiscoverCertificatesResult> {
+  async discoverByIdentityKey (args: { identityKey: PubKeyHex, limit?: PositiveIntegerDefault10Max10000, offset?: PositiveIntegerOrZero }): Promise<DiscoverCertificatesResult> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).discoverByIdentityKey(args, this.originator)
   }
 
-  async discoverByAttributes(args: { attributes: Record<CertificateFieldNameUnder50Bytes, string>, limit?: PositiveIntegerDefault10Max10000, offset?: PositiveIntegerOrZero }): Promise<DiscoverCertificatesResult> {
+  async discoverByAttributes (args: { attributes: Record<CertificateFieldNameUnder50Bytes, string>, limit?: PositiveIntegerDefault10Max10000, offset?: PositiveIntegerOrZero }): Promise<DiscoverCertificatesResult> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).discoverByAttributes(args, this.originator)
   }
 
-  async isAuthenticated(args: {} = {}): Promise<{ authenticated: boolean }> {
+  async isAuthenticated (args: {} = {}): Promise<{ authenticated: boolean }> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).isAuthenticated(args, this.originator)
   }
 
-  async waitForAuthentication(args: {} = {}): Promise<{ authenticated: true }> {
+  async waitForAuthentication (args: {} = {}): Promise<{ authenticated: true }> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).waitForAuthentication(args, this.originator)
   }
 
-  async getHeight(args: {} = {}): Promise<{ height: PositiveInteger }> {
+  async getHeight (args: {} = {}): Promise<{ height: PositiveInteger }> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).getHeight(args, this.originator)
   }
 
-  async getHeaderForHeight(args: { height: PositiveInteger }): Promise<{ header: HexString }> {
+  async getHeaderForHeight (args: { height: PositiveInteger }): Promise<{ header: HexString }> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).getHeaderForHeight(args, this.originator)
   }
 
-  async getNetwork(args: {} = {}): Promise<{ network: 'mainnet' | 'testnet' }> {
+  async getNetwork (args: {} = {}): Promise<{ network: 'mainnet' | 'testnet' }> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).getNetwork(args, this.originator)
   }
 
-  async getVersion(args: {} = {}): Promise<{ version: VersionString7To30Bytes }> {
+  async getVersion (args: {} = {}): Promise<{ version: VersionString7To30Bytes }> {
     await this.connectToSubstrate()
     return await (this.substrate as Wallet).getVersion(args, this.originator)
   }

package/src/wallet/WalletError.ts

@@ -2,7 +2,7 @@ export class WalletError extends Error {
   code: number
   isError: boolean = true
 
-  constructor(message: string, code = 1, stack?: string) {
+  constructor (message: string, code = 1, stack?: string) {
     super(message)
     this.code = code
     this.name = this.constructor.name
@@ -24,4 +24,4 @@ enum walletErrors {
 }
 
 export default walletErrors
-export type WalletErrorCode = keyof typeof walletErrors
+export type WalletErrorCode = keyof typeof walletErrors