@bsv/sdk 1.2.11 → 1.2.13

package/docs/transaction.md

@@ -135,6 +135,7 @@ This interface defines a standard method for broadcasting transactions.
 ```ts
 export interface Broadcaster {
     broadcast: (transaction: Transaction) => Promise<BroadcastResponse | BroadcastFailure>;
+    broadcastMany?: (txs: Transaction[]) => Promise<object[]>;
 }
 ```
 

package/docs/wallet.md

@@ -1294,6 +1294,7 @@ Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](
 | |
 | --- |
 | [CachedKeyDeriver](#class-cachedkeyderiver) |
+| [HTTPWalletJSON](#class-httpwalletjson) |
 | [HTTPWalletWire](#class-httpwalletwire) |
 | [KeyDeriver](#class-keyderiver) |
 | [ProtoWallet](#class-protowallet) |
@@ -1500,6 +1501,230 @@ Argument Details
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Enums](#enums), [Variables](#variables)
 
+---
+### Class: HTTPWalletJSON
+
+```ts
+export default class HTTPWalletJSON implements Wallet {
+    baseUrl: string;
+    httpClient: typeof fetch;
+    originator: OriginatorDomainNameStringUnder250Bytes | undefined;
+    api: (call: string, args: any) => Promise<any>;
+    constructor(originator: OriginatorDomainNameStringUnder250Bytes | undefined, baseUrl: string = "http://localhost:3321", httpClient = fetch) 
+    async createAction(args: CreateActionArgs): Promise<CreateActionResult> 
+    async signAction(args: SignActionArgs): Promise<SignActionResult> 
+    async abortAction(args: {
+        reference: Base64String;
+    }): Promise<{
+        aborted: true;
+    }> 
+    async listActions(args: ListActionsArgs): Promise<ListActionsResult> 
+    async internalizeAction(args: InternalizeActionArgs): Promise<{
+        accepted: true;
+    }> 
+    async listOutputs(args: ListOutputsArgs): Promise<ListOutputsResult> 
+    async relinquishOutput(args: {
+        basket: BasketStringUnder300Bytes;
+        output: OutpointString;
+    }): Promise<{
+        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;
+    }> 
+    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 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 encrypt(args: {
+        seekPermission?: BooleanDefaultTrue;
+        plaintext: Byte[];
+        protocolID: [
+            SecurityLevel,
+            ProtocolString5To400Bytes
+        ];
+        keyID: KeyIDStringUnder800Bytes;
+        privilegedReason?: DescriptionString5to50Bytes;
+        counterparty?: PubKeyHex | "self" | "anyone";
+        privileged?: BooleanDefaultFalse;
+    }): Promise<{
+        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[];
+    }> 
+    async createHmac(args: {
+        seekPermission?: BooleanDefaultTrue;
+        data: Byte[];
+        protocolID: [
+            SecurityLevel,
+            ProtocolString5To400Bytes
+        ];
+        keyID: KeyIDStringUnder800Bytes;
+        privilegedReason?: DescriptionString5to50Bytes;
+        counterparty?: PubKeyHex | "self" | "anyone";
+        privileged?: BooleanDefaultFalse;
+    }): Promise<{
+        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;
+    }> 
+    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 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 acquireCertificate(args: AcquireCertificateArgs): Promise<AcquireCertificateResult> 
+    async listCertificates(args: {
+        certifiers: PubKeyHex[];
+        types: Base64String[];
+        limit?: PositiveIntegerDefault10Max10000;
+        offset?: PositiveIntegerOrZero;
+        privileged?: BooleanDefaultFalse;
+        privilegedReason?: DescriptionString5to50Bytes;
+    }): Promise<ListCertificatesResult> 
+    async proveCertificate(args: ProveCertificateArgs): Promise<ProveCertificateResult> 
+    async relinquishCertificate(args: {
+        type: Base64String;
+        serialNumber: Base64String;
+        certifier: PubKeyHex;
+    }): Promise<{
+        relinquished: true;
+    }> 
+    async discoverByIdentityKey(args: {
+        seekPermission?: BooleanDefaultTrue;
+        identityKey: PubKeyHex;
+        limit?: PositiveIntegerDefault10Max10000;
+        offset?: PositiveIntegerOrZero;
+    }): Promise<DiscoverCertificatesResult> 
+    async discoverByAttributes(args: {
+        seekPermission?: BooleanDefaultTrue;
+        attributes: Record<CertificateFieldNameUnder50Bytes, string>;
+        limit?: PositiveIntegerDefault10Max10000;
+        offset?: PositiveIntegerOrZero;
+    }): Promise<DiscoverCertificatesResult> 
+    async isAuthenticated(args: {}): Promise<{
+        authenticated: boolean;
+    }> 
+    async waitForAuthentication(args: {}): Promise<{
+        authenticated: true;
+    }> 
+    async getHeight(args: {}): Promise<{
+        height: PositiveInteger;
+    }> 
+    async getHeaderForHeight(args: {
+        height: PositiveInteger;
+    }): Promise<{
+        header: HexString;
+    }> 
+    async getNetwork(args: {}): Promise<{
+        network: "mainnet" | "testnet";
+    }> 
+    async getVersion(args: {}): Promise<{
+        version: VersionString7To30Bytes;
+    }> 
+}
+```
+
+See also: [AcquireCertificateArgs](#interface-acquirecertificateargs), [AcquireCertificateResult](#interface-acquirecertificateresult), [Base64String](#type-base64string), [BasketStringUnder300Bytes](#type-basketstringunder300bytes), [BooleanDefaultFalse](#type-booleandefaultfalse), [BooleanDefaultTrue](#type-booleandefaulttrue), [Byte](#type-byte), [CertificateFieldNameUnder50Bytes](#type-certificatefieldnameunder50bytes), [CreateActionArgs](#interface-createactionargs), [CreateActionResult](#interface-createactionresult), [DescriptionString5to50Bytes](#type-descriptionstring5to50bytes), [DiscoverCertificatesResult](#interface-discovercertificatesresult), [HexString](#type-hexstring), [ISOTimestampString](#type-isotimestampstring), [InternalizeActionArgs](#interface-internalizeactionargs), [KeyIDStringUnder800Bytes](#type-keyidstringunder800bytes), [ListActionsArgs](#interface-listactionsargs), [ListActionsResult](#interface-listactionsresult), [ListCertificatesResult](#interface-listcertificatesresult), [ListOutputsArgs](#interface-listoutputsargs), [ListOutputsResult](#interface-listoutputsresult), [OriginatorDomainNameStringUnder250Bytes](#type-originatordomainnamestringunder250bytes), [OutpointString](#type-outpointstring), [PositiveInteger](#type-positiveinteger), [PositiveIntegerDefault10Max10000](#type-positiveintegerdefault10max10000), [PositiveIntegerOrZero](#type-positiveintegerorzero), [ProtocolString5To400Bytes](#type-protocolstring5to400bytes), [ProveCertificateArgs](#interface-provecertificateargs), [ProveCertificateResult](#interface-provecertificateresult), [PubKeyHex](#type-pubkeyhex), [SecurityLevel](#type-securitylevel), [SignActionArgs](#interface-signactionargs), [SignActionResult](#interface-signactionresult), [VersionString7To30Bytes](#type-versionstring7to30bytes), [Wallet](#interface-wallet), [decrypt](#variable-decrypt), [encrypt](#variable-encrypt)
+
+Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Enums](#enums), [Variables](#variables)
+
 ---
 ### Class: HTTPWalletWire
 
@@ -2157,7 +2382,7 @@ The SDK is how applications communicate with wallets over a communications subst
 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" | "json-api" | Wallet = "auto", originator?: OriginatorDomainNameStringUnder250Bytes) 
     async connectToSubstrate() 
     async createAction(args: CreateActionArgs): Promise<CreateActionResult> 
     async signAction(args: SignActionArgs): Promise<SignActionResult> 

package/package.json

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

package/src/primitives/__tests/PrivateKey.test.ts

@@ -11,9 +11,9 @@ describe('PrivateKey', () => {
     BRC42Private.forEach((vector, index) => {
       it(`Passes BRC42 private vector #${index + 1}`, () => {
         const publicKey = PublicKey.fromString(vector.senderPublicKey)
-        const privateKey = PrivateKey.fromString(vector.recipientPrivateKey, 16)
+        const privateKey = PrivateKey.fromString(vector.recipientPrivateKey)
         const derived = privateKey.deriveChild(publicKey, vector.invoiceNumber)
-        expect(derived.toHex(32)).toEqual(vector.privateKey)
+        expect(derived.toHex()).toEqual(vector.privateKey)
       })
     })
   })

package/src/transaction/Broadcaster.ts

@@ -40,10 +40,14 @@ export interface BroadcastFailure {
  * @interface
  * @property {function} broadcast - A function that takes a Transaction object and returns a promise.
  *                                  The promise resolves to either a BroadcastResponse or a BroadcastFailure.
+ * @property {function} broadcastMany - A function that takes an array of Transaction objects and returns a promise.
+ *                                  The promise resolves to an array of broadcast result response objects.
  */
 export interface Broadcaster {
   broadcast: (transaction: Transaction) =>
   Promise<BroadcastResponse | BroadcastFailure>
+  broadcastMany?: (txs: Transaction[]) =>
+  Promise<object[]>
 }
 
 /**

package/src/transaction/Transaction.ts

@@ -12,7 +12,7 @@ import Spend from '../script/Spend.js'
 import ChainTracker from './ChainTracker.js'
 import { defaultBroadcaster } from './broadcasters/DefaultBroadcaster.js'
 import { defaultChainTracker } from './chaintrackers/DefaultChainTracker.js'
-import { BEEF_MAGIC } from './Beef.js'
+import { ATOMIC_BEEF, BEEF_MAGIC } from './Beef.js'
 
 /**
  * Represents a complete Bitcoin transaction. This class encapsulates all the details
@@ -119,8 +119,8 @@ export default class Transaction {
     const reader = new Reader(beef)
     // Read the Atomic BEEF prefix
     const prefix = reader.readUInt32LE()
-    if (prefix !== 0x01010101) {
-      throw new Error(`Invalid Atomic BEEF prefix. Expected 0x01010101, received ${prefix.toString(16)}.`)
+    if (prefix !== ATOMIC_BEEF) {
+      throw new Error(`Invalid Atomic BEEF prefix. Expected 0x01010101, received 0x${prefix.toString(16)}.`)
     }
 
     // Read the subject TXID

package/src/wallet/WalletClient.ts

@@ -3,6 +3,7 @@ import WindowCWISubstrate from './substrates/window.CWI.js'
 import XDMSubstrate from './substrates/XDM.js'
 import WalletWireTransceiver from './substrates/WalletWireTransceiver.js'
 import HTTPWalletWire from './substrates/HTTPWalletWire.js'
+import HTTPWalletJSON from './substrates/HTTPWalletJSON.js'
 
 const MAX_XDM_RESPONSE_WAIT = 200
 
@@ -12,10 +13,11 @@ 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' | 'json-api' | 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()
+    if (substrate === 'json-api') substrate = new HTTPWalletJSON(originator)
     this.substrate = substrate
     this.originator = originator
   }
@@ -54,7 +56,13 @@ export default class WalletClient implements Wallet {
           await checkSub()
           this.substrate = sub
         } catch (e) {
-          throw new Error('No wallet available over any communication substrate. Install a BSV wallet today!')
+          try {
+            sub = new HTTPWalletJSON(this.originator)
+            await checkSub()
+            this.substrate = sub
+          } catch (e) {
+            throw new Error('No wallet available over any communication substrate. Install a BSV wallet today!')
+          }
         }
       }
     }

package/src/wallet/substrates/HTTPWalletJSON.ts

@@ -0,0 +1,143 @@
+import { Wallet, 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'
+
+export default class HTTPWalletJSON implements Wallet {
+  baseUrl: string
+  httpClient: typeof fetch
+  originator: OriginatorDomainNameStringUnder250Bytes | undefined
+  api: (call: string, args: any) => Promise<any>
+
+  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()
+        return response
+      } catch (error) {
+        console.log({ 'HTTPWalletJSON': { call, args, error }})
+        throw error
+      }
+    }
+  }
+
+  async createAction(args: CreateActionArgs): Promise<CreateActionResult> {
+    return await this.api('createAction', args)
+  }
+
+  async signAction(args: SignActionArgs): Promise<SignActionResult> {
+    return await this.api('signAction', args)
+  }
+
+  async abortAction(args: { reference: Base64String }): Promise<{ aborted: true }> {
+    return await this.api('abortAction', args)
+  }
+
+  async listActions(args: ListActionsArgs): Promise<ListActionsResult> {
+    return await this.api('listActions', args)
+  }
+
+  async internalizeAction(args: InternalizeActionArgs): Promise<{ accepted: true }> {
+    return await this.api('internalizeAction', args)
+  }
+
+  async listOutputs(args: ListOutputsArgs): Promise<ListOutputsResult> {
+    return await this.api('listOutputs', args)
+  }
+
+  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 }> {
+    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[] }> {
+    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 }> {
+    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[] }> {
+    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[] }> {
+    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[] }> {
+    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 }> {
+    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[] }> {
+    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 }> {
+    return await this.api('verifySignature', args)
+  }
+
+  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> {
+    return await this.api('listCertificates', args)
+  }
+
+  async proveCertificate(args: ProveCertificateArgs): Promise<ProveCertificateResult> {
+    return await this.api('proveCertificate', args)
+  }
+
+  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> {
+    return await this.api('discoverByIdentityKey', args)
+  }
+
+  async discoverByAttributes(args: { seekPermission?: BooleanDefaultTrue, attributes: Record<CertificateFieldNameUnder50Bytes, string>, limit?: PositiveIntegerDefault10Max10000, offset?: PositiveIntegerOrZero }): Promise<DiscoverCertificatesResult> {
+    return await this.api('discoverByAttributes', args)
+  }
+
+  async isAuthenticated(args: {}): Promise<{ authenticated: boolean }> {
+    return await this.api('isAuthenticated', args)
+  }
+
+  async waitForAuthentication(args: {}): Promise<{ authenticated: true }> {
+    return await this.api('waitForAuthentication', args)
+  }
+
+  async getHeight(args: {}): Promise<{ height: PositiveInteger }> {
+    return await this.api('getHeight', args)
+  }
+
+  async getHeaderForHeight(args: { height: PositiveInteger }): Promise<{ header: HexString }> {
+    return await this.api('getHeaderForHeight', args)
+  }
+
+  async getNetwork(args: {}): Promise<{ network: 'mainnet' | 'testnet' }> {
+    return await this.api('getNetwork', args)
+  }
+
+  async getVersion(args: {}): Promise<{ version: VersionString7To30Bytes }> {
+    return await this.api('getVersion', args)
+  }
+}