@atomicfinance/bitcoin-wallet-provider 2.5.0 → 3.0.1

package/.turbo/turbo-build.log

@@ -0,0 +1 @@
+@atomicfinance/bitcoin-wallet-provider:build: cache hit, replaying output 98a9bcec703e0822

package/.turbo/turbo-test.log

@@ -0,0 +1 @@
+@atomicfinance/bitcoin-wallet-provider:test: cache hit, replaying output d2bf08a921f65444

package/CHANGELOG.md

@@ -0,0 +1,31 @@
+# @atomicfinance/bitcoin-wallet-provider
+
+## 3.0.1
+
+### Patch Changes
+
+- @atomicfinance/bitcoin-utils@3.0.1
+- @atomicfinance/provider@3.0.1
+- @atomicfinance/types@3.0.1
+
+## 3.0.0
+
+### Major Changes
+
+- a06082e: Create unified standalone `bitcoin-abstraction-layer` package
+
+### Patch Changes
+
+- Updated dependencies [a06082e]
+  - @atomicfinance/provider@3.0.0
+  - @atomicfinance/types@3.0.0
+  - @atomicfinance/bitcoin-utils@3.0.0
+
+## 2.5.1
+
+### Patch Changes
+
+- Upgrade various package dependencies
+- Updated dependencies
+  - @atomicfinance/provider@2.5.1
+  - @atomicfinance/types@2.5.1

package/dist/BitcoinWalletProvider.d.ts

@@ -1,91 +1,120 @@
+/// <reference types="node" />
+import { CoinSelectTarget } from '@atomicfinance/bitcoin-utils';
 import Provider from '@atomicfinance/provider';
-import { CreateMultisigResponse, finalizePSBTResponse, FinanceWalletProvider, Input, Output } from '@atomicfinance/types';
-import { BitcoinNetwork } from '@liquality/bitcoin-networks';
-import { Address, bitcoin as bT, Transaction } from '@liquality/types';
+import { Address, bitcoin as bT, SendOptions, Transaction } from '@atomicfinance/types';
+import { BitcoinNetwork } from 'bitcoin-networks';
 import * as bitcoin from 'bitcoinjs-lib';
+import { BIP32Interface } from 'bitcoinjs-lib';
 declare type UnusedAddressesBlacklist = {
     [address: string]: true;
 };
-export default class BitcoinWalletProvider extends Provider implements Partial<FinanceWalletProvider> {
-    _network: BitcoinNetwork;
-    _unusedAddressesBlacklist: UnusedAddressesBlacklist;
-    _maxAddressesToDerive: number;
-    constructor(network: BitcoinNetwork);
-    buildSweepTransactionWithSetOutputs(externalChangeAddress: string, feePerByte: number, _outputs: Output[], fixedInputs: Input[]): Promise<{
-        hex: string;
-        fee: number;
-    }>;
-    getUnusedAddressesBlacklist(): UnusedAddressesBlacklist;
-    setUnusedAddressesBlacklist(unusedAddressesBlacklist: UnusedAddressesBlacklist): void;
-    setMaxAddressesToDerive(maxAddressesToDerive: number): void;
-    getMaxAddressesToDerive(): number;
-    _createMultisigPayment(m: number, pubkeys: string[]): bitcoin.Payment;
-    /**
-     * Creates a native-segwit multi-signature address (P2MS in P2WSH) with n signatures of m required keys
-     * https://developer.bitcoin.org/reference/rpc/createmultisig.html
-     * @param m the number of required signatures
-     * @param pubkeys n possible pubkeys in total
-     * @returns a json object containing the `address` and `redeemScript`
-     */
-    createMultisig(m: number, pubkeys: string[]): CreateMultisigResponse;
-    /**
-     * Creates a PSBT of a native-segwit multi-signature address (P2MS in P2WSH) with n signatures of m required keys
-     * https://developer.bitcoin.org/reference/rpc/createmultisig.html
-     * https://developer.bitcoin.org/reference/rpc/createpsbt.html
-     * @param m the number of required signatures
-     * @param pubkeys n possible pubkeys in total
-     * @param inputs the Inputs to the PSBT
-     * @param ouputs the Outputs to the PSBT
-     * @returns a base64 encoded psbt string
-     */
-    buildMultisigPSBT(m: number, pubkeys: string[], inputs: Input[], outputs: Output[]): string;
-    /**
-     * Update a PSBT with input information from our wallet and then sign inputs that we can sign for
-     * https://developer.bitcoin.org/reference/rpc/walletprocesspsbt.html
-     * @param psbt a base64 encoded psbt string (P2WSH only)
-     * @returns a base64 encoded signed psbt string
-     */
-    walletProcessPSBT(psbtString: string): Promise<string>;
-    /**
-     * Finalize the inputs of a PSBT. If the transaction is fully signed, it will
-     * produce a network serialized transaction which can be broadcast with sendrawtransaction
-     * https://developer.bitcoin.org/reference/rpc/finalizepsbt.html
-     * @param psbt a base64 encoded psbt string
-     * @returns a json object containing `psbt` in base64, `hex` for transaction and `complete` for if
-     * the transaction has a complete set of signatures
-     */
-    finalizePSBT(psbtString: string): finalizePSBTResponse;
-    getUnusedAddress(change?: boolean, numAddressPerCall?: number): Promise<any>;
-    _getUsedUnusedAddresses(numAddressPerCall: number, addressType: any): Promise<{
-        usedAddresses: any[];
-        unusedAddress: {
+export declare enum AddressSearchType {
+    EXTERNAL = 0,
+    CHANGE = 1,
+    EXTERNAL_OR_CHANGE = 2
+}
+declare type DerivationCache = {
+    [index: string]: Address;
+};
+declare type Constructor<T = unknown> = new (...args: any[]) => T;
+declare const _default: <T extends Constructor<Provider>>(superclass: T) => {
+    new (...args: any[]): {
+        _network: BitcoinNetwork;
+        _unusedAddressesBlacklist: UnusedAddressesBlacklist;
+        _maxAddressesToDerive: number;
+        _baseDerivationPath: string;
+        _addressType: bT.AddressType;
+        _derivationCache: DerivationCache;
+        baseDerivationNode(): Promise<BIP32Interface>;
+        _buildTransaction(targets: bT.OutputTarget[], feePerByte?: number, fixedInputs?: bT.Input[]): Promise<{
+            hex: string;
+            fee: number;
+        }>;
+        _buildSweepTransaction(externalChangeAddress: string, feePerByte?: number): Promise<{
+            hex: string;
+            fee: number;
+        }>;
+        signPSBT(data: string, inputs: bT.PsbtInputTarget[]): Promise<string>;
+        signBatchP2SHTransaction(inputs: [
+            {
+                inputTxHex: string;
+                index: number;
+                vout: any;
+                outputScript: Buffer;
+            }
+        ], addresses: string, tx: any, lockTime?: number, segwit?: boolean): Promise<Buffer[]>;
+        getDerivationCache(): DerivationCache;
+        setDerivationCache(derivationCache: DerivationCache): Promise<void>;
+        sendOptionsToOutputs(transactions: SendOptions[]): bT.OutputTarget[];
+        buildTransaction(output: bT.OutputTarget, feePerByte: number): Promise<{
+            hex: string;
+            fee: number;
+        }>;
+        buildBatchTransaction(outputs: bT.OutputTarget[]): Promise<{
+            hex: string;
+            fee: number;
+        }>;
+        _sendTransaction(transactions: bT.OutputTarget[], feePerByte?: number): Promise<Transaction<bT.Transaction>>;
+        sendTransaction(options: SendOptions): Promise<Transaction<bT.Transaction>>;
+        sendBatchTransaction(transactions: SendOptions[]): Promise<Transaction<bT.Transaction>>;
+        buildSweepTransaction(externalChangeAddress: string, feePerByte: number): Promise<{
+            hex: string;
+            fee: number;
+        }>;
+        sendSweepTransaction(externalChangeAddress: Address | string, feePerByte: number): Promise<Transaction<bT.Transaction>>;
+        getUnusedAddressesBlacklist(): UnusedAddressesBlacklist;
+        setUnusedAddressesBlacklist(unusedAddressesBlacklist: UnusedAddressesBlacklist): void;
+        setMaxAddressesToDerive(maxAddressesToDerive: number): void;
+        getMaxAddressesToDerive(): number;
+        updateTransactionFee(tx: Transaction<bitcoin.Transaction> | string, newFeePerByte: number): Promise<Transaction<bT.Transaction>>;
+        getUnusedAddress(change?: boolean, numAddressPerCall?: number): Promise<any>;
+        _getUsedUnusedAddresses(numAddressPerCall: number, addressType: any): Promise<{
+            usedAddresses: any[];
+            unusedAddress: {
+                change: any;
+                nonChange: any;
+            };
+            firstUnusedAddress: any;
+        }>;
+        getWalletAddress(address: string): Promise<Address>;
+        getAddressFromPublicKey(publicKey: Buffer): string;
+        getPaymentVariantFromPublicKey(publicKey: Buffer): bitcoin.payments.Payment;
+        getDerivationPathAddress(path: string): Promise<Address>;
+        /**
+         * getAddresses is an optimized version of upstream CAL's getAddresses.
+         * It removes the call to `asyncSetImmediate()`, speeding up the function by a factor of 6x.
+         *
+         * @param startingIndex
+         * @param numAddresses
+         * @param change
+         * @returns {Promise<Address[]>}
+         */
+        getAddresses(startingIndex?: number, numAddresses?: number, change?: boolean): 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[], change?: boolean | null): Promise<Address>;
+        getUsedAddresses(numAddressPerCall?: number): Promise<any[]>;
+        withCachedUtxos(func: () => any): Promise<any>;
+        getTotalFee(opts: SendOptions, max: boolean): Promise<number>;
+        getTotalFees(transactions: SendOptions[], max: boolean): Promise<any>;
+        getInputsForAmount(_targets: bT.OutputTarget[], feePerByte?: number, fixedInputs?: bT.Input[], numAddressPerCall?: number, sweep?: boolean): Promise<{
+            inputs: bT.UTXO[];
             change: any;
-            nonChange: any;
-        };
-        firstUnusedAddress: any;
-    }>;
-    sendSweepTransactionWithSetOutputs(externalChangeAddress: string, feePerByte: number, _outputs: Output[], fixedInputs: Input[]): Promise<Transaction<bT.Transaction>>;
-    _buildSweepTransaction(externalChangeAddress: string, feePerByte: number, _outputs: Output[], fixedInputs: Input[]): Promise<{
-        hex: string;
-        fee: number;
-    }>;
-    _getInputForAmountWithoutUtxoCheck(_outputs: Output[], _feePerByte: number, fixedInputs: Input[]): {
-        inputs: bT.UTXO[];
-        outputs: {
-            value: number;
-            id?: string;
-        }[];
-        fee: number;
-        change: {
-            value: number;
-            id?: string;
-        };
+            outputs: CoinSelectTarget[];
+            fee: number;
+        }>;
+        client: import("@atomicfinance/types").IClient;
+        setClient(client?: import("@atomicfinance/types").IClient): void;
+        getMethod(method: string, requestor?: any): (...args: any[]) => any;
     };
-    _buildTransactionWithoutUtxoCheck(outputs: Output[], feePerByte: number, fixedInputs: Input[]): Promise<{
-        hex: string;
-        fee: number;
-    }>;
-    quickGetAddresses(startingIndex?: number, numAddresses?: number, change?: boolean): Promise<Address[]>;
-    quickFindAddress(addresses: string[]): Promise<Address>;
-}
-export {};
+} & T;
+export default _default;