@atomicfinance/types 2.5.1 → 3.0.0

package/dist/transaction.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxStatus = void 0;
+var TxStatus;
+(function (TxStatus) {
+    TxStatus["Pending"] = "PENDING";
+    TxStatus["Failed"] = "FAILED";
+    TxStatus["Success"] = "SUCCESS";
+})(TxStatus = exports.TxStatus || (exports.TxStatus = {}));
+//# sourceMappingURL=transaction.js.map

package/dist/transaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../lib/transaction.ts"],"names":[],"mappings":";;;AAuBA,IAAY,QAIX;AAJD,WAAY,QAAQ;IAClB,+BAAmB,CAAA;IACnB,6BAAiB,CAAA;IACjB,+BAAmB,CAAA;AACrB,CAAC,EAJW,QAAQ,GAAR,gBAAQ,KAAR,gBAAQ,QAInB"}

package/dist/wallet.d.ts

@@ -1,5 +1,83 @@
+import { Address } from './address';
+import Input from './models/Input';
+import Output from './models/Output';
 export interface finalizePSBTResponse {
     psbt: string;
     hex?: string;
     complete: boolean;
 }
+export interface WalletProvider {
+    /**
+     * 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.
+     */
+    getAddresses(startingIndex?: number, numAddresses?: number, change?: boolean): Promise<Address[]>;
+    /**
+     * 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.
+     */
+    getUsedAddresses(numAddressPerCall?: number): Promise<Address[]>;
+    /**
+     * findAddress is an optimized version of upstream CAL's findAddress.
+     *
+     * It searches through both change and non-change addresses (if change arg is not provided) each iteration.
+     *
+     * This is in contrast to the original findAddress function which searches
+     * through all non-change addresses before moving on to change addresses.
+     *
+     * @param addresses
+     * @returns {Promise<Address>}
+     */
+    findAddress(addresses: string[]): Promise<Address>;
+    /**
+     * 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.
+     */
+    getUnusedAddress(change?: boolean, numAddressPerCall?: number): Promise<Address>;
+    /**
+     * 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.
+     */
+    signMessage(message: string, from: string): Promise<string>;
+    /**
+     * Retrieve the network connected to by the wallet
+     * @return {Promise<any>} Resolves with the network object
+     */
+    getConnectedNetwork(): Promise<any>;
+    /**
+     * Retrieve the availability status of the wallet
+     * @return {Promise<Boolean>} True if the wallet is available to use
+     */
+    isWalletAvailable(): Promise<boolean>;
+    /**
+     * Flag indicating if the wallet allows apps to update transaction fees
+     * @return {Promise<Boolean>} True if wallet accepts fee updating
+     */
+    canUpdateFee?: boolean | (() => boolean);
+    /**
+     * Exports the private key for the account
+     * for BTC, https://en.bitcoin.it/wiki/Wallet_import_format
+     * for ETH, the privateKey
+     * for NEAR, the secretKey
+     * @return {Promise<string>} Resolves with the key as a string
+     */
+    exportPrivateKey?: () => Promise<string>;
+    buildSweepTransactionWithSetOutputs(externalChangeAddress: string, feePerByte: number, _outputs: Output[], fixedInputs: Input[]): any;
+    getUnusedAddressesBlacklist(): any;
+    setUnusedAddressesBlacklist(unusedAddressesBlacklist: any): any;
+    sendSweepTransactionWithSetOutputs(externalChangeAddress: string, feePerByte: number, _outputs: Output[], fixedInputs: Input[]): any;
+}

package/lib/address.ts

@@ -0,0 +1,13 @@
+export class Address {
+  address: string;
+  derivationPath?: string;
+  publicKey?: string;
+
+  constructor(fields?: {
+    address: string;
+    derivationPath?: string;
+    publicKey?: string;
+  }) {
+    if (fields) Object.assign(this, fields);
+  }
+}

package/lib/bitcoin.ts

@@ -0,0 +1,72 @@
+export interface OutputTarget {
+  address?: string;
+  script?: Buffer;
+  value: number;
+}
+
+export interface ScriptPubKey {
+  asm: string;
+  hex: string;
+  reqSigs: number;
+  type: string;
+  addresses: string[];
+}
+
+export interface Output {
+  value: number;
+  n: number;
+  scriptPubKey: ScriptPubKey;
+}
+
+export interface Input {
+  txid: string;
+  vout: number;
+  scriptSig: {
+    asm: string;
+    hex: string;
+  };
+  txinwitness: string[];
+  sequence: number;
+  coinbase?: string;
+}
+
+export interface Transaction {
+  txid: string;
+  hash: string;
+  version: number;
+  locktime: number;
+  size: number;
+  vsize: number;
+  weight: number;
+  vin: Input[];
+  vout: Output[];
+  confirmations?: number;
+  hex: string;
+}
+
+export interface UTXO {
+  txid: string;
+  vout: number;
+  value: number;
+  address: string;
+  derivationPath?: string;
+}
+
+export enum AddressType {
+  LEGACY = 'legacy',
+  P2SH_SEGWIT = 'p2sh-segwit',
+  BECH32 = 'bech32',
+}
+
+export enum SwapMode {
+  P2SH = 'p2sh',
+  P2SH_SEGWIT = 'p2shSegwit',
+  P2WSH = 'p2wsh',
+}
+
+export type AddressTxCounts = { [index: string]: number };
+
+export interface PsbtInputTarget {
+  index: number;
+  derivationPath: string;
+}

package/lib/block.ts

@@ -0,0 +1,18 @@
+export interface Block<TransactionType = any> {
+  // Block number
+  number: number;
+  // Block hash
+  hash: string;
+  // Block timestamp in seconds
+  timestamp: number;
+  // The size of this block in bytes
+  size: number;
+  // Hash of the parent block
+  parentHash: string;
+  // The difficulty field
+  difficulty?: number;
+  // Nonce
+  nonce?: number;
+  // List of transactions
+  transactions?: TransactionType[];
+}

package/lib/chain.ts

@@ -0,0 +1,126 @@
+import BigNumber from 'bignumber.js';
+
+import { Address } from './address';
+import { Block } from './block';
+import { Transaction } from './transaction';
+
+export interface SendOptions {
+  to: Address | string;
+  value: BigNumber;
+  data?: string;
+  fee?: number;
+}
+
+export interface ChainProvider {
+  /**
+   * Generate a block
+   * @param {!number} numberOfBlocks - Number of blocks to be generated
+   * @return {<Promise>}
+   */
+  generateBlock(numberOfBlocks: number): Promise<void>;
+
+  /**
+   * Get a block given its hash.
+   * @param {!string} blockHash - A hexadecimal string that represents the
+   *  *hash* of the desired block.
+   * @param {boolean} [includeTx=false] - If true, fetches transactions in the block.
+   * @return {Promise<Block, TypeError|InvalidProviderResponseError>}
+   *  Resolves with a Block with the same hash as the given input.
+   *  If `includeTx` is true, the transaction property is an array of Transactions;
+   *  otherwise, it is a list of transaction hashes.
+   *  Rejects with TypeError if input is invalid.
+   *  Rejects with InvalidProviderResponseError if provider's response is invalid.
+   */
+  getBlockByHash(blockHash: string, includeTx?: boolean): Promise<Block>;
+
+  /**
+   * Get a block given its number.
+   * @param {!number} blockNumber - The number of the desired block.
+   * @param {boolean} [includeTx=false] - If true, fetches transaction in the block.
+   * @return {Promise<Block, TypeError|InvalidProviderResponseError>}
+   *  Resolves with a Block with the same number as the given input.
+   *  If `includeTx` is true, the transaction property is an array of Transactions;
+   *  otherwise, it is a list of transaction hashes.
+   *  Rejects with TypeError if input is invalid.
+   *  Rejects with InvalidProviderResponseError if provider's response is invalid.
+   */
+  getBlockByNumber(blockNumber: number, includeTx?: boolean): Promise<Block>;
+
+  /**
+   * Get current block height of the chain.
+   * @return {Promise<number, InvalidProviderResponseError>} Resolves with
+   *  chain height.
+   *  Rejects with InvalidProviderResponseError if provider's response is invalid.
+   */
+  getBlockHeight(): Promise<number>;
+
+  /**
+   * Get a transaction given its hash.
+   * @param {!string} txHash - A hexadecimal string that represents the *hash* of the
+   *  desired transaction.
+   * @return {Promise<Transaction, TypeError|InvalidProviderResponseError>}
+   *  Resolves with a Transaction with the same hash as the given input.
+   *  Rejects with TypeError if input is invalid.
+   *  Rejects with InvalidProviderResponseError if provider's response is invalid.
+   */
+  getTransactionByHash(txHash: string): Promise<Transaction>;
+
+  /**
+   * Get the balance of an account given its addresses.
+   * @param {(string | Address)[]} addresses - A list of addresses.
+   * @return {Promise<BigNumber, InvalidProviderResponseError>} If addresses is given,
+   *  returns the cumulative balance of the given addresses. Otherwise returns the balance
+   *  of the addresses that the signing provider controls.
+   *  Rejects with InvalidProviderResponseError if provider's response is invalid.
+   */
+  getBalance(addresses: (Address | string)[]): Promise<BigNumber>;
+
+  /**
+   * Create, sign & broadcast a transaction.
+   * @param {!string} to - Recepient address.
+   * @param {!number} value - Value of transaction.
+   * @param {!string} data - Data to be passed to the transaction.
+   * @param {!Fee} [fee] - Fee price in native unit (e.g. sat/b, wei)
+   * @return {Promise<Transaction>} Resolves with a signed transaction.
+   */
+  sendTransaction(options: SendOptions): Promise<Transaction>;
+
+  /**
+   * Create, sign & broadcast a sweep transaction.
+   * @param {!string} address - External address.
+   * @param {Fee} [fee] - Fee price in native unit (e.g. sat/b, wei)
+   * @return {Promise<Transaction>} Resolves with a signed transaction.
+   */
+  sendSweepTransaction(
+    address: Address | string,
+    fee?: number,
+  ): Promise<Transaction>;
+
+  /**
+   * Update the fee of a transaction.
+   * @param {(string|Transaction)} tx - Transaction object or hash of the transaction to update
+   * @param {!Fee} newFee - New fee price in native unit (e.g. sat/b, wei)
+   * @return {Promise<Transaction>} Resolves with the new transaction
+   */
+  updateTransactionFee(
+    tx: string | Transaction,
+    newFee: number,
+  ): Promise<Transaction>;
+
+  /**
+   * Create, sign & broad a transaction with multiple outputs.
+   * @param {string[]} transactions - to, value, data
+   * @return {Promise<Transaction>} Resolves with a signed transaction.
+   */
+  sendBatchTransaction(transactions: SendOptions[]): Promise<Transaction>;
+
+  /**
+   * Broadcast a signed transaction to the network.
+   * @param {!string} rawTransaction - A raw transaction usually in the form of a
+   *  hexadecimal string that represents the serialized transaction.
+   * @return {Promise<string, InvalidProviderResponseError>} Resolves with an
+   *  identifier for the broadcasted transaction.
+   *  Rejects with InvalidProviderResponseError if provider's response is invalid.
+   */
+  sendRawTransaction(rawTransaction: string): Promise<string>;
+}

package/lib/fees.ts

@@ -0,0 +1,21 @@
+export interface FeeDetail {
+  // Fee price
+  fee: number;
+  // Estimated time to confirmation
+  wait?: number;
+}
+
+export interface FeeDetails {
+  slow: FeeDetail;
+  average: FeeDetail;
+  fast: FeeDetail;
+}
+
+export interface FeeProvider {
+  /**
+   * @return {Promise<FeeDetails>} Resolves with an
+   *  identifier for the broadcasted transaction.
+   *  Rejects with InvalidProviderResponseError if provider's response is invalid.
+   */
+  getFees(): Promise<FeeDetails>;
+}

package/lib/index.ts

@@ -1,11 +1,18 @@
-import { Provider } from '@liquality/provider';
-import { ChainProvider, SwapProvider, WalletProvider } from '@liquality/types';
+import BigNumber from 'bignumber.js';
 
+import { Address } from './address';
+import * as bitcoin from './bitcoin';
+import { Block } from './block';
 import { CfdProvider } from './cfd';
+import { ChainProvider, SendOptions } from './chain';
 import { DlcProvider } from './dlc';
-import { FinanceWalletProvider } from './financewallet';
+import { FeeDetail, FeeDetails, FeeProvider } from './fees';
+import * as BitcoinJsonRpcTypes from './jsonrpc';
+import { Network } from './network';
+import { Transaction, TxStatus } from './transaction';
+import { WalletProvider } from './wallet';
 
-interface IFinanceClient {
+interface IClient {
   /**
    * Helper method that returns method from a provider.
    * @param {!string} method - Name of the method to look for in the provider stack
@@ -14,20 +21,17 @@ interface IFinanceClient {
    * @return {function} Returns method from provider instance associated with the requested method
    */
   getMethod(method: string, requestor?: any): () => any;
-  getProviderForMethod(method: string, requestor?: boolean): Provider;
+  getProviderForMethod(method: string, requestor?: boolean): any;
 
   chain: ChainProvider;
-  swap: SwapProvider;
   wallet: WalletProvider;
   cfd: CfdProvider;
   dlc: DlcProvider;
-  financewallet: FinanceWalletProvider;
 }
 
 export * from './cfd';
 export * from './common';
 export * from './dlc';
-export * from './financewallet';
 export { default as Amount } from './models/Amount';
 export { default as Input } from './models/Input';
 export { default as OracleInfo } from './models/OracleInfo';
@@ -35,4 +39,22 @@ export { default as Outcome } from './models/Outcome';
 export { default as Output } from './models/Output';
 export { default as Utxo } from './models/Utxo';
 export * from './wallet';
-export { IFinanceClient, CfdProvider, DlcProvider, FinanceWalletProvider };
+export {
+  BigNumber,
+  IClient,
+  CfdProvider,
+  DlcProvider,
+  ChainProvider,
+  WalletProvider,
+  Address,
+  SendOptions,
+  Block,
+  Transaction,
+  TxStatus,
+  FeeDetails,
+  FeeDetail,
+  FeeProvider,
+  Network,
+  BitcoinJsonRpcTypes,
+  bitcoin,
+};

package/lib/jsonrpc.ts

@@ -0,0 +1,81 @@
+import { Transaction } from './bitcoin';
+
+export interface UTXO {
+  txid: string;
+  vout: number;
+  address: string;
+  label: string;
+  scriptPubKey: string;
+  amount: number;
+  confirmations: number;
+  redeemScript: string;
+  witnessScript: string;
+  spendable: boolean;
+  solvable: boolean;
+  desc: string;
+  safe: boolean;
+}
+
+export interface ReceivedByAddress {
+  involvesWatchOnly: boolean;
+  address: string;
+  account: string;
+  amount: number;
+  cofirmations: number;
+  label: string;
+  txids: string[];
+}
+
+export interface MinedTransaction extends Transaction {
+  blockhash: string;
+  confirmations: number;
+  blocktime: number;
+  number: number;
+}
+
+export interface FundRawResponse {
+  hex: string;
+  fee: number;
+  changepos: number;
+}
+
+export interface AddressInfo {
+  iswatchonly: boolean;
+  pubkey: string;
+  hdkeypath: string;
+  // ...
+}
+
+export type AddressGrouping = string[][];
+
+export interface ReceivedByAddress {
+  involvesWatchonly: boolean;
+  address: string;
+  account: string;
+  amount: number;
+  confirmations: number;
+  label: string;
+  txids: string[];
+}
+
+export interface Block {
+  hash: string;
+  confirmations: number;
+  size: number;
+  strippedSize: number;
+  weight: number;
+  height: number;
+  version: number;
+  versionHex: string;
+  merkleroot: string;
+  tx: string[];
+  time: number;
+  mediantime: number;
+  nonce: number;
+  bits: string;
+  difficulty: number;
+  chainwork: string;
+  nTx: number;
+  previousblockhash: string;
+  nextblockhash?: string;
+}

package/lib/models/Input.ts

@@ -1,21 +1,20 @@
-import { bitcoin as bT } from '@liquality/types';
-
+import * as bT from '../bitcoin';
 import Amount from './Amount';
 import Utxo from './Utxo';
 
 /**
- * Class for interfacing with inputs/utxos in Liquality ChainAbstractionLayer
- * https://github.com/liquality/chainabstractionlayer
+ * Class for interfacing with inputs/utxos in Liquality Chainify
+ * https://github.com/liquality/chainify
  *
  * These inputs can have different fields for value
- * satoshis (sats): https://github.com/liquality/chainabstractionlayer/blob/dev/packages/bitcoin-esplora-api-provider/lib/BitcoinEsploraApiProvider.js#L65
- * amount (btc): https://github.com/liquality/chainabstractionlayer/blob/dev/packages/bitcoin-esplora-api-provider/lib/BitcoinEsploraApiProvider.js#L74
- * value (sats): https://github.com/liquality/chainabstractionlayer/blob/dev/packages/bitcoin-wallet-provider/lib/BitcoinWalletProvider.js#L331
+ * satoshis (sats): https://github.com/liquality/chainify/blob/dev/packages/bitcoin-esplora-api-provider/lib/BitcoinEsploraApiProvider.js#L65
+ * amount (btc): https://github.com/liquality/chainify/blob/dev/packages/bitcoin-esplora-api-provider/lib/BitcoinEsploraApiProvider.js#L74
+ * value (sats): https://github.com/liquality/chainify/blob/dev/packages/bitcoin-wallet-provider/lib/BitcoinWalletProvider.js#L331
  *
  * This will be fixed once typescript branch is merged:
- * https://github.com/liquality/chainabstractionlayer/tree/typescript
+ * https://github.com/liquality/chainify/tree/typescript
  * satoshis and amount will not be necessary, only value
- * https://github.com/liquality/chainabstractionlayer/blob/typescript/packages/types/lib/bitcoin.ts#L46
+ * https://github.com/liquality/chainify/blob/typescript/packages/types/lib/bitcoin.ts#L46
  */
 export default class Input {
   constructor(

package/lib/network.ts

@@ -0,0 +1,5 @@
+export interface Network {
+  name: string;
+  coinType: string;
+  isTestnet: boolean;
+}

package/lib/transaction.ts

@@ -0,0 +1,28 @@
+export interface Transaction<T = any> {
+  // Transaction hash
+  hash: string;
+  // The value of the transaction
+  value: number;
+  // transaction status
+  status?: TxStatus;
+  // Hash of the block containing the transaction
+  blockHash?: string;
+  // The block number containing the trnasaction
+  blockNumber?: number;
+  // The number of confirmations of the transaction
+  confirmations?: number;
+  // The price per unit of fee
+  feePrice?: number;
+  // The total fee paid for the transaction
+  fee?: number;
+  // Secret of a HTLC
+  secret?: string;
+  // The raw transaction object
+  _raw: T;
+}
+
+export enum TxStatus {
+  Pending = 'PENDING',
+  Failed = 'FAILED',
+  Success = 'SUCCESS',
+}

package/lib/wallet.ts

@@ -1,5 +1,114 @@
+import { Address } from './address';
+import Input from './models/Input';
+import Output from './models/Output';
+
 export interface finalizePSBTResponse {
   psbt: string;
   hex?: string;
   complete: boolean;
 }
+
+export interface WalletProvider {
+  /**
+   * 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.
+   */
+  getAddresses(
+    startingIndex?: number,
+    numAddresses?: number,
+    change?: boolean,
+  ): Promise<Address[]>;
+
+  /**
+   * 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.
+   */
+  getUsedAddresses(numAddressPerCall?: number): Promise<Address[]>;
+
+  /**
+   * findAddress is an optimized version of upstream CAL's findAddress.
+   *
+   * It searches through both change and non-change addresses (if change arg is not provided) each iteration.
+   *
+   * This is in contrast to the original findAddress function which searches
+   * through all non-change addresses before moving on to change addresses.
+   *
+   * @param addresses
+   * @returns {Promise<Address>}
+   */
+  findAddress(addresses: string[]): Promise<Address>;
+
+  /**
+   * 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.
+   */
+  getUnusedAddress(
+    change?: boolean,
+    numAddressPerCall?: number,
+  ): Promise<Address>;
+
+  /**
+   * 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.
+   */
+  signMessage(message: string, from: string): Promise<string>;
+
+  /**
+   * Retrieve the network connected to by the wallet
+   * @return {Promise<any>} Resolves with the network object
+   */
+  getConnectedNetwork(): Promise<any>;
+
+  /**
+   * Retrieve the availability status of the wallet
+   * @return {Promise<Boolean>} True if the wallet is available to use
+   */
+  isWalletAvailable(): Promise<boolean>;
+
+  /**
+   * Flag indicating if the wallet allows apps to update transaction fees
+   * @return {Promise<Boolean>} True if wallet accepts fee updating
+   */
+  canUpdateFee?: boolean | (() => boolean);
+
+  /**
+   * Exports the private key for the account
+   * for BTC, https://en.bitcoin.it/wiki/Wallet_import_format
+   * for ETH, the privateKey
+   * for NEAR, the secretKey
+   * @return {Promise<string>} Resolves with the key as a string
+   */
+  exportPrivateKey?: () => Promise<string>;
+
+  buildSweepTransactionWithSetOutputs(
+    externalChangeAddress: string,
+    feePerByte: number,
+    _outputs: Output[],
+    fixedInputs: Input[],
+  );
+
+  getUnusedAddressesBlacklist();
+
+  setUnusedAddressesBlacklist(unusedAddressesBlacklist);
+
+  sendSweepTransactionWithSetOutputs(
+    externalChangeAddress: string,
+    feePerByte: number,
+    _outputs: Output[],
+    fixedInputs: Input[],
+  );
+}