@bsv/sdk 1.2.10 → 1.2.12

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<Array<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.10",
+  "version": "1.2.12",
   "type": "module",
   "description": "BSV Blockchain Software Development Kit",
   "main": "dist/cjs/mod.js",

package/src/primitives/PrivateKey.ts

@@ -93,8 +93,21 @@ export default class PrivateKey extends BigNumber {
    * @returns The generated Private Key.
    * @throws Will throw an error if the string is not valid.
    **/
-  static fromString (str: string, base: number | 'hex'): PrivateKey {
-    return new PrivateKey(BigNumber.fromString(str, base).toArray())
+  static fromString (str: string, base: number | 'hex' = 'hex'): PrivateKey {
+    return new PrivateKey(super.fromString(str, base).toArray())
+  }
+
+  /**
+   * Generates a private key from a hexadecimal string.
+   *
+   * @method fromHex
+   * @static
+   * @param {string} str - The hexadecimal string representing the private key. The string must represent a valid private key in big-endian format.
+   * @returns {PrivateKey} The generated Private Key instance.
+   * @throws {Error} If the string is not a valid hexadecimal or represents an invalid private key.
+   **/
+  static fromHex (str: string): PrivateKey {
+    return new PrivateKey(super.fromHex(str, 'big'))
   }
 
   /**
@@ -274,6 +287,34 @@ export default class PrivateKey extends BigNumber {
     return this.toPublicKey().toAddress(prefix)
   }
 
+  /**
+   * Converts this PrivateKey to a hexadecimal string.
+   *
+   * @method toHex
+   * @param length - The minimum length of the hex string
+   * @returns Returns a string representing the hexadecimal value of this BigNumber.
+   *
+   * @example
+   * const bigNumber = new BigNumber(255);
+   * const hex = bigNumber.toHex();
+   */
+  toHex (): string {
+    return super.toHex(32)
+  }
+
+  /**
+   * Converts this PrivateKey to a string representation.
+   *
+   * @method toString
+   * @param {number | 'hex'} [base='hex'] - The base for representing the number. Default is hexadecimal ('hex').
+   * @param {number} [padding=64] - The minimum number of digits for the output string. Default is 64, ensuring a 256-bit representation in hexadecimal.
+   * @returns {string} A string representation of the PrivateKey in the specified base, padded to the specified length.
+   *
+   **/
+  toString (base: number | 'hex' = 'hex', padding: number = 64): string {
+    return super.toString(base, padding)
+  }
+
   /**
    * Derives a shared secret from the public key.
    *

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

@@ -1,17 +1,97 @@
 import PublicKey from '../../../dist/cjs/src/primitives/PublicKey'
 import PrivateKey from '../../../dist/cjs/src/primitives/PrivateKey'
 import BRC42Private from './BRC42.private.vectors'
+import Curve from '../../../dist/cjs/src/primitives/Curve'
+import BigNumber from '../../../dist/cjs/src/primitives/BigNumber'
 
 describe('PrivateKey', () => {
   describe('BRC42 vectors', () => {
-    for (let i = 0; i < BRC42Private.length; i++) {
-      it(`Passes BRC42 private vector #${i + 1}`, () => {
-        const v = BRC42Private[i]
-        const publicKey = PublicKey.fromString(v.senderPublicKey)
-        const privateKey = PrivateKey.fromString(v.recipientPrivateKey, 16)
-        const derived = privateKey.deriveChild(publicKey, v.invoiceNumber)
-        expect(derived.toHex(32)).toEqual(v.privateKey)
+    const curve = new Curve()
+
+    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 derived = privateKey.deriveChild(publicKey, vector.invoiceNumber)
+        expect(derived.toHex(32)).toEqual(vector.privateKey)
       })
+    })
+  })
+
+  describe('PrivateKey Validation and Conversion', () => {
+    const curve = new Curve()
+
+    const isValidPrivateKey = (key) => {
+      try {
+        const keyAsNumber = new BigNumber(key, 16)
+        return (
+          !keyAsNumber.isZero() &&
+          keyAsNumber.cmp(curve.n) < 0 &&
+          key.length === 64
+        )
+      } catch (e) {
+        return false
+      }
     }
+
+    it('Validates and converts valid private keys between hex and string', () => {
+      const validKeys = [
+        '0000000000000000000000000000000000000000000000000000000000000001',
+        'fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140',
+        '8a2f85e08360a04c8a36b7c22c5e9e9a0d3bcf2f95c97db2b8bd90fc5f5ff66a',
+        '1b5a8f2392e6959a7de2b0a58f8a64cc528c9bfc1788ee0d32e1455063e71545'
+      ]
+
+      validKeys.forEach((key, index) => {
+        const privateKeyFromHex = PrivateKey.fromHex(key)
+        const privateKeyFromString = PrivateKey.fromString(key, 'hex')
+        const privateKeyToHex = privateKeyFromHex.toHex()
+        const privateKeyToString = privateKeyFromString.toString('hex')
+        expect(isValidPrivateKey(privateKeyToHex)).toBe(true)
+        expect(isValidPrivateKey(privateKeyToString)).toBe(true)
+
+        // Round-trip conversion checks
+        expect(privateKeyToHex).toEqual(key)
+        expect(privateKeyToString).toEqual(key)
+      })
+    })
+
+    // it('Rejects invalid private keys during validation and conversion', () => {
+    //   const invalidKeys = [
+    //     '0000000000000000000000000000000000000000000000000000000000000000',
+    //     'fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141',
+    //     'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
+    //     'fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe',
+    //     '1234567890abcdef',
+    //     'fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd03641',
+    //     'fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364',
+    //   ]
+
+    //   invalidKeys.forEach((key, index) => {
+    //     const isValid = isValidPrivateKey(key)
+    //     expect(isValid).toBe(false)
+    //     // Ensure invalid keys throw an error during conversion
+    //     expect(() => PrivateKey.fromHex(key)).toThrow()
+    //     expect(() => PrivateKey.fromString(key, 'hex')).toThrow()
+    //   })
+    // })
+
+    it('Tests 10,000 random private keys for valid conversions', () => {
+      for (let i = 0; i < 10000; i++) {
+        const privateKey = PrivateKey.fromRandom()
+        const privateKeyHex = privateKey.toHex()
+        const privateKeyString = privateKey.toString('hex')
+
+        // Validate the random key's format
+        expect(isValidPrivateKey(privateKeyHex)).toBe(true)
+        expect(isValidPrivateKey(privateKeyString)).toBe(true)
+
+        // Round-trip conversion checks
+        const roundTripHex = PrivateKey.fromHex(privateKeyHex).toHex()
+        const roundTripString = PrivateKey.fromString(privateKeyString, 'hex').toString('hex')
+        expect(roundTripHex).toEqual(privateKeyHex)
+        expect(roundTripString).toEqual(privateKeyString)
+      }
+    })
   })
 })

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/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)
+  }
+}