@atomicfinance/client 2.5.0 → 3.0.1

package/dist/schema/Block.json

@@ -0,0 +1,45 @@
+{
+    "$id": "https://dev.liquality.com/schema/block.json",
+    "title": "Block",
+    "description": "Blockchain block",
+    "type": "object",
+    "required": ["number", "hash", "timestamp", "size"],
+    "properties": {
+        "hash": {
+            "type": "string",
+            "title": "Hash"
+        },
+        "number": {
+            "type": "number",
+            "title": "Number",
+            "minimum": 0
+        },
+        "timestamp": {
+            "type": "number",
+            "title": "Timestamp",
+            "minimum": 0
+        },
+        "difficulty": {
+            "type": "number",
+            "title": "Difficulty",
+            "minLength": 1
+        },
+        "size": {
+            "type": "number",
+            "title": "Size",
+            "minimum": 0
+        },
+        "parentHash": {
+            "type": "string",
+            "title": "Parent Hash"
+        },
+        "nonce": {
+            "type": "number",
+            "title": "Nonce",
+            "minimum": 0
+        },
+        "_raw": {
+            "type": "object"
+        }
+    }
+}

package/dist/schema/Transaction.json

@@ -0,0 +1,45 @@
+{
+    "$id": "https://dev.liquality.com/schema/transaction.json",
+    "title": "Transaction",
+    "description": "Blockchain transaction",
+    "type": "object",
+    "required": ["hash", "value"],
+    "properties": {
+        "blockHash": {
+            "type": "string",
+            "title": "Block Hash"
+        },
+        "blockNumber": {
+            "type": "number",
+            "title": "Block Number",
+            "minimum": 0
+        },
+        "hash": {
+            "type": "string",
+            "title": "Transaction Hash"
+        },
+        "value": {
+            "type": "number",
+            "title": "Value",
+            "minimum": 0
+        },
+        "confirmations": {
+            "type": "number",
+            "title": "Confirmations",
+            "minimum": 0
+        },
+        "feePrice": {
+            "type": "number",
+            "title": "Fee Price",
+            "minimum": 0
+        },
+        "fee": {
+            "type": "number",
+            "title": "Fee",
+            "minimum": 0
+        },
+        "_raw": {
+            "type": "object"
+        }
+    }
+}

package/dist/schema/index.d.ts

@@ -0,0 +1,3 @@
+import Block from './Block.json';
+import Transaction from './Transaction.json';
+export { Block, Transaction };

package/dist/schema/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transaction = exports.Block = void 0;
+const Block_json_1 = __importDefault(require("./Block.json"));
+exports.Block = Block_json_1.default;
+const Transaction_json_1 = __importDefault(require("./Transaction.json"));
+exports.Transaction = Transaction_json_1.default;
+//# sourceMappingURL=index.js.map

package/dist/schema/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../lib/schema/index.ts"],"names":[],"mappings":";;;;;;AAAA,8DAAiC;AAGxB,gBAHF,oBAAK,CAGE;AAFd,0EAA6C;AAE7B,sBAFT,0BAAW,CAES"}

package/lib/Cfd.ts

@@ -15,6 +15,7 @@ import {
   BlindRawTransactionResponse,
   CalculateEcSignatureRequest,
   CalculateEcSignatureResponse,
+  CfdProvider,
   ConvertAesRequest,
   ConvertAesResponse,
   ConvertEntropyToMnemonicRequest,
@@ -138,7 +139,7 @@ import {
   VerifySignResponse,
 } from '@atomicfinance/types';
 
-export default class Cfd {
+export default class Cfd implements CfdProvider {
   client: any;
 
   constructor(client: any) {

package/lib/Chain.ts

@@ -0,0 +1,173 @@
+import { InvalidProviderResponseError } from '@atomicfinance/errors';
+import {
+  Address,
+  BigNumber,
+  Block,
+  ChainProvider,
+  FeeDetails,
+  FeeProvider,
+  SendOptions,
+  Transaction,
+} from '@atomicfinance/types';
+import { isBoolean, isNumber, isObject, isString } from 'lodash';
+
+export default class Chain implements ChainProvider, FeeProvider {
+  client: any;
+
+  constructor(client: any) {
+    this.client = client;
+  }
+
+  /** @inheritdoc */
+  async generateBlock(numberOfBlocks: number): Promise<void> {
+    if (!isNumber(numberOfBlocks)) {
+      throw new TypeError('First argument should be a number');
+    }
+
+    return this.client.getMethod('generateBlock')(numberOfBlocks);
+  }
+
+  /** @inheritdoc */
+  async getBlockByHash(blockHash: string, includeTx = false): Promise<Block> {
+    if (!isString(blockHash)) {
+      throw new TypeError('Block hash should be a string');
+    }
+
+    if (!isBoolean(includeTx)) {
+      throw new TypeError('Second parameter should be boolean');
+    }
+
+    const block = await this.client.getMethod('getBlockByHash')(
+      blockHash,
+      includeTx,
+    );
+    this.client.assertValidBlock(block);
+    return block;
+  }
+
+  /** @inheritdoc */
+  async getBlockByNumber(
+    blockNumber: number,
+    includeTx = false,
+  ): Promise<Block> {
+    if (!isNumber(blockNumber)) {
+      throw new TypeError('Invalid Block number');
+    }
+
+    if (!isBoolean(includeTx)) {
+      throw new TypeError('Second parameter should be boolean');
+    }
+
+    const block = await this.client.getMethod('getBlockByNumber')(
+      blockNumber,
+      includeTx,
+    );
+    this.client.assertValidBlock(block);
+    return block;
+  }
+
+  /** @inheritdoc */
+  async getBlockHeight(): Promise<number> {
+    const blockHeight = await this.client.getMethod('getBlockHeight')();
+
+    if (!isNumber(blockHeight)) {
+      throw new InvalidProviderResponseError(
+        'Provider returned an invalid block height',
+      );
+    }
+
+    return blockHeight;
+  }
+
+  /** @inheritdoc */
+  async getTransactionByHash(txHash: string): Promise<Transaction> {
+    if (!isString(txHash)) {
+      throw new TypeError('Transaction hash should be a string');
+    }
+
+    const transaction = await this.client.getMethod('getTransactionByHash')(
+      txHash,
+    );
+    if (transaction) {
+      this.client.assertValidTransaction(transaction);
+    }
+
+    return transaction;
+  }
+
+  /** @inheritdoc */
+  async getBalance(addresses: (string | Address)[]): Promise<BigNumber> {
+    const balance = await this.client.getMethod('getBalance')(addresses);
+
+    if (!BigNumber.isBigNumber(balance)) {
+      throw new InvalidProviderResponseError(
+        'Provider returned an invalid response',
+      );
+    }
+
+    return balance;
+  }
+
+  /** @inheritdoc */
+  async sendTransaction(options: SendOptions): Promise<Transaction> {
+    const transaction = await this.client.getMethod('sendTransaction')(options);
+    this.client.assertValidTransaction(transaction);
+    return transaction;
+  }
+
+  /** @inheritdoc */
+  async sendSweepTransaction(
+    address: Address | string,
+    fee?: number,
+  ): Promise<Transaction> {
+    return this.client.getMethod('sendSweepTransaction')(address, fee);
+  }
+
+  /** @inheritdoc */
+  async updateTransactionFee(
+    tx: string | Transaction,
+    newFee: number,
+  ): Promise<Transaction> {
+    if (isObject(tx)) {
+      this.client.assertValidTransaction(tx);
+    } else {
+      if (!isString(tx)) {
+        throw new TypeError('Transaction should be a string or object');
+      }
+    }
+
+    const transaction = await this.client.getMethod('updateTransactionFee')(
+      tx,
+      newFee,
+    );
+    this.client.assertValidTransaction(transaction);
+    return transaction;
+  }
+
+  /** @inheritdoc */
+  async sendBatchTransaction(
+    transactions: SendOptions[],
+  ): Promise<Transaction> {
+    return this.client.getMethod('sendBatchTransaction')(transactions);
+  }
+
+  /** @inheritdoc */
+  async sendRawTransaction(rawTransaction: string): Promise<string> {
+    const txHash = await this.client.getMethod('sendRawTransaction')(
+      rawTransaction,
+    );
+
+    if (!isString(txHash)) {
+      throw new InvalidProviderResponseError(
+        'sendRawTransaction method should return a transaction id string',
+      );
+    }
+
+    return txHash;
+  }
+
+  /** @inheritdoc */
+  async getFees(): Promise<FeeDetails> {
+    return this.client.getMethod('getFees')();
+  }
+}

package/lib/Client.ts

@@ -1,36 +1,178 @@
-import FinanceProvider from '@atomicfinance/provider';
-import { Client } from '@liquality/client';
-import { Provider } from '@liquality/provider';
+import {
+  DuplicateProviderError,
+  InvalidProviderError,
+  InvalidProviderResponseError,
+  NoProviderError,
+  UnimplementedMethodError,
+  UnsupportedMethodError,
+} from '@atomicfinance/errors';
+import Provider from '@atomicfinance/provider';
+import { Block, IClient, Transaction } from '@atomicfinance/types';
+import Ajv from 'ajv';
+import { find, findLast, findLastIndex, isFunction } from 'lodash';
 
 import Cfd from './Cfd';
+import Chain from './Chain';
 import Dlc from './Dlc';
+import {
+  Block as BlockSchema,
+  Transaction as TransactionSchema,
+} from './schema';
 import Wallet from './Wallet';
 
-export default class FinanceClient extends Client {
+export default class Client implements IClient {
+  _providers: Provider[];
   version: string;
+
+  validateTransaction: Ajv.ValidateFunction;
+  validateBlock: Ajv.ValidateFunction;
+
   _dlc: Dlc;
   _cfd: Cfd;
-  _financewallet: Wallet;
+  _wallet: Wallet;
+  _chain: Chain;
   identifier: string;
 
   /**
    * Client
    */
-  constructor(provider?: Provider | FinanceProvider, version?: string) {
-    super(provider, version);
-
+  constructor(provider?: Provider, version?: string) {
     /**
      * @type {Array}
      */
     this._providers = [];
 
+    /**
+     * @type {string}
+     */
+    this.version = version;
+
+    if (provider) {
+      this.addProvider(provider);
+    }
+
+    const ajv = new Ajv();
+    this.validateTransaction = ajv.compile(TransactionSchema);
+    this.validateBlock = ajv.compile(BlockSchema);
+
+    this._chain = new Chain(this);
     this._dlc = new Dlc(this);
     this._cfd = new Cfd(this);
-    this._financewallet = new Wallet(this);
+    this._wallet = new Wallet(this);
 
     this.identifier = 'Client';
   }
 
+  /**
+   * Add a provider
+   * @param {!Provider} provider - The provider instance or RPC connection string
+   * @return {Client} Returns instance of Client
+   * @throws {InvalidProviderError} When invalid provider is provider
+   * @throws {DuplicateProviderError} When same provider is added again
+   */
+  addProvider(provider: Provider) {
+    if (!isFunction(provider.setClient)) {
+      throw new InvalidProviderError('Provider should have "setClient" method');
+    }
+
+    const duplicate = find(
+      this._providers,
+      (_provider) => provider.constructor === _provider.constructor,
+    );
+
+    if (duplicate) {
+      throw new DuplicateProviderError('Duplicate provider');
+    }
+
+    provider.setClient(this);
+    this._providers.push(provider);
+
+    return this;
+  }
+
+  /**
+   * Check the availability of a method.
+   * @param {!string} method - Name of the method to look for in the provider stack
+   * @param {boolean|object} [requestor=false] - If provided, it returns providers only
+   *  above the requestor in the stack.
+   * @return {Provider} Returns a provider instance associated with the requested method
+   * @throws {NoProviderError} When no provider is available in the stack.
+   * @throws {UnimplementedMethodError} When the requested method is not provided
+   *  by any provider above requestor in the provider stack
+   * @throws {UnsupportedMethodError} When requested method is not supported by
+   *  version specified
+   */
+  getProviderForMethod(method: string, requestor = false) {
+    if (this._providers.length === 0) {
+      throw new NoProviderError(
+        'No provider provided. Add a provider to the client',
+      );
+    }
+
+    let indexOfRequestor = requestor
+      ? findLastIndex(
+          this._providers,
+          (provider) => requestor.constructor === provider.constructor,
+        )
+      : this._providers.length;
+
+    if (indexOfRequestor === -1) indexOfRequestor = 0;
+
+    const provider = findLast(
+      this._providers,
+      (provider) => isFunction((<any>provider)[method]),
+      indexOfRequestor - 1,
+    );
+
+    if (provider == null) {
+      throw new UnimplementedMethodError(`Unimplemented method "${method}"`);
+    }
+
+    if (isFunction((<any>provider)._checkMethodVersionSupport)) {
+      if (!(<any>provider)._checkMethodVersionSupport(method, this.version)) {
+        throw new UnsupportedMethodError(
+          `Method "${method}" is not supported by version "${this.version}"`,
+        );
+      }
+    }
+
+    return provider;
+  }
+
+  /**
+   * Helper method that returns method from a provider.
+   * @param {!string} method - Name of the method to look for in the provider stack
+   * @param {object} [requestor] - If provided, it returns method from providers only
+   *  above the requestor in the stack.
+   * @return {function} Returns method from provider instance associated with the requested method
+   */
+  getMethod(method: string, requestor?: any) {
+    const provider = this.getProviderForMethod(method, requestor);
+    return (<any>provider)[method].bind(provider);
+  }
+
+  assertValidTransaction(transaction: Transaction) {
+    if (!this.validateTransaction(transaction)) {
+      const { errors } = this.validateTransaction;
+      throw new InvalidProviderResponseError(
+        `Provider returned an invalid transaction, "${errors[0].dataPath}" ${errors[0].message}`,
+      );
+    }
+  }
+
+  assertValidBlock(block: Block) {
+    if (!this.validateBlock(block)) {
+      const { errors } = this.validateBlock;
+      throw new InvalidProviderResponseError(
+        `Provider returned an invalid block, "${errors[0].dataPath}" ${errors[0].message}`,
+      );
+    }
+  }
+
+  get chain() {
+    return this._chain;
+  }
+
   get dlc() {
     return this._dlc;
   }
@@ -39,7 +181,7 @@ export default class FinanceClient extends Client {
     return this._cfd;
   }
 
-  get financewallet() {
-    return this._financewallet;
+  get wallet() {
+    return this._wallet;
   }
 }

package/lib/Dlc.ts

@@ -16,6 +16,7 @@ import {
   CreateFundTransactionResponse,
   CreateRefundTransactionRequest,
   CreateRefundTransactionResponse,
+  DlcProvider,
   GetRawFundTxSignatureRequest,
   GetRawFundTxSignatureResponse,
   GetRawRefundTxSignatureRequest,
@@ -47,7 +48,7 @@ import {
 } from '@node-dlc/messaging';
 import { Tx } from '@node-lightning/bitcoin';
 
-export default class Dlc {
+export default class Dlc implements DlcProvider {
   client: any;
 
   constructor(client: any) {
@@ -391,6 +392,28 @@ export default class Dlc {
     return this.client.getMethod('VerifyCetAdaptorSignature')(jsonObject);
   }
 
+  async VerifyCetAdaptorSignatures(
+    jsonObject: VerifyCetAdaptorSignaturesRequest,
+  ): Promise<VerifyCetAdaptorSignaturesResponse> {
+    return this.client.getMethod('VerifyCetAdaptorSignatures')(jsonObject);
+  }
+
+  async GetInputsForAmount(
+    amount: bigint,
+    feeRatePerVb: bigint,
+    fixedInputs: Input[],
+  ): Promise<Input[]> {
+    return this.client.getMethod('GetInputsForAmount')(
+      amount,
+      feeRatePerVb,
+      fixedInputs,
+    );
+  }
+
+  async SignCet(jsonObject: SignCetRequest): Promise<SignCetResponse> {
+    return this.client.getMethod('SignCet')(jsonObject);
+  }
+
   async VerifyCetAdaptorSignaturesRequest(
     jsonObject: VerifyCetAdaptorSignaturesRequest,
   ): Promise<VerifyCetAdaptorSignaturesResponse> {

package/lib/Wallet.ts

@@ -1,13 +1,140 @@
-import { CreateMultisigResponse, Input, Output } from '@atomicfinance/types';
+import {
+  InvalidProviderResponseError,
+  UnimplementedMethodError,
+} from '@atomicfinance/errors';
+import {
+  Address,
+  CreateMultisigResponse,
+  Input,
+  Output,
+  WalletProvider,
+} from '@atomicfinance/types';
 import { Transaction } from 'bitcoinjs-lib';
+import { isArray } from 'lodash';
 
-export default class Wallet {
+export default class Wallet implements WalletProvider {
   client: any;
 
   constructor(client: any) {
     this.client = client;
   }
 
+  /**
+   * Get addresses/accounts of the user.
+   * @param {number} [startingIndex] - Index to start
+   * @param {number} [numAddresses] - Number of addresses to retrieve
+   * @param {boolean} [change] - True for change addresses
+   * @return {Promise<Address[], InvalidProviderResponseError>} Resolves with a list
+   *  of addresses.
+   *  Rejects with InvalidProviderResponseError if provider's response is invalid.
+   */
+  async getAddresses(
+    startingIndex?: number,
+    numAddresses?: number,
+    change?: boolean,
+  ): Promise<Address[]> {
+    const addresses = await this.client.getMethod('getAddresses')(
+      startingIndex,
+      numAddresses,
+      change,
+    );
+
+    if (!isArray(addresses)) {
+      throw new InvalidProviderResponseError(
+        'Provider returned an invalid response',
+      );
+    }
+
+    return addresses;
+  }
+
+  /**
+   * Get used addresses/accounts of the user.
+   * @param {number} [numAddressPerCall] - Number of addresses to retrieve per call
+   * @return {Promise<Address[], InvalidProviderResponseError>} Resolves with a list
+   *  of addresses.
+   *  Rejects with InvalidProviderResponseError if provider's response is invalid.
+   */
+  async getUsedAddresses(numAddressPerCall?: number): Promise<Address[]> {
+    return this.client.getMethod('getUsedAddresses')(numAddressPerCall);
+  }
+
+  /**
+   * Get unused address/account of the user.
+   * @param {boolean} [change] - True for change addresses
+   * @param {number} [numAddressPerCall] - Number of addresses to retrieve per call
+   * @return {Promise<Address, InvalidProviderResponseError>} Resolves with a address
+   *  object.
+   *  Rejects with InvalidProviderResponseError if provider's response is invalid.
+   */
+  async getUnusedAddress(
+    change?: boolean,
+    numAddressPerCall?: number,
+  ): Promise<Address> {
+    return this.client.getMethod('getUnusedAddress')(change, numAddressPerCall);
+  }
+
+  /**
+   * Sign a message.
+   * @param {!string} message - Message to be signed.
+   * @param {!string} from - The address from which the message is signed.
+   * @return {Promise<string>} Resolves with a signed message.
+   */
+  async signMessage(message: string, from: string): Promise<string> {
+    return this.client.getMethod('signMessage')(message, from);
+  }
+
+  /**
+   * Retrieve the network connected to by the wallet
+   * @return {Promise<any>} Resolves with the network object
+   */
+  async getConnectedNetwork(): Promise<any> {
+    return this.client.getMethod('getConnectedNetwork')();
+  }
+
+  /**
+   * Retrieve the availability status of the wallet
+   * @return {Promise<Boolean>} True if the wallet is available to use
+   */
+  async isWalletAvailable(): Promise<boolean> {
+    return this.client.getMethod('isWalletAvailable')();
+  }
+
+  /**
+   * Flag indicating if the wallet allows apps to update transaction fees
+   * @return {Promise<Boolean>} True if wallet accepts fee updating
+   */
+  get canUpdateFee(): boolean {
+    try {
+      return this.client.getMethod('canUpdateFee')();
+    } catch (e) {
+      if (!(e instanceof UnimplementedMethodError)) throw e;
+    }
+    return true;
+  }
+
+  /**
+   * Retrieve the private key for the account
+   * @return {Promise<string>} Resolves with the key as a string
+   */
+  exportPrivateKey(): Promise<string> {
+    return this.client.getMethod('exportPrivateKey')();
+  }
+
+  findAddress(addresses: string[]) {
+    return this.client.getMethod('findAddress')(addresses);
+  }
+
+  setUnusedAddressesBlacklist(unusedAddressesBlacklist: any) {
+    return this.client.getMethod('setUnusedAddressesBlacklist')(
+      unusedAddressesBlacklist,
+    );
+  }
+
+  getUnusedAddressesBlacklist() {
+    return this.client.getMethod('getUnusedAddressesBlacklist')();
+  }
+
   createMultisig(m: number, pubkeys: string[]): CreateMultisigResponse {
     return this.client.getMethod('createMultisig')(m, pubkeys);
   }
@@ -61,12 +188,4 @@ export default class Wallet {
       fixedInputs,
     );
   }
-
-  async getUnusedAddress(change = false, numAddressPerCall = 100) {
-    return this.client.getMethod('getUnusedAddress')(change, numAddressPerCall);
-  }
-
-  async quickFindAddress(addresses: string[]) {
-    return this.client.getMethod('quickFindAddress')(addresses);
-  }
 }