beignet 0.0.1

package/dist/types/types/wallet.d.ts

@@ -0,0 +1,400 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Result } from '../utils';
+import { IHeader, INewBlock, TElectrumNetworks, TServer, TTxResult } from './electrum';
+import { EFeeId } from './transaction';
+import { TLSSocket } from 'tls';
+import { Server } from 'net';
+export type TAvailableNetworks = 'bitcoin' | 'testnet' | 'regtest';
+export type TAddressType = 'p2wpkh' | 'p2sh' | 'p2pkh';
+export type TAddressLabel = 'bech32' | 'segwit' | 'legacy';
+export type TKeyDerivationPurpose = '84' | '49' | '44' | string;
+export type TKeyDerivationCoinType = '0' | '1' | string;
+export type TKeyDerivationAccount = '0' | string;
+export type TKeyDerivationChange = '0' | '1';
+export type TKeyDerivationIndex = string;
+export type TAddressTypes = {
+    [key in EAddressType]: Readonly<IAddressTypeData>;
+};
+export declare enum EAvailableNetworks {
+    bitcoin = "bitcoin",
+    mainnet = "bitcoin",
+    bitcoinMainnet = "bitcoin",
+    testnet = "testnet",
+    bitcoinTestnet = "testnet",
+    regtest = "regtest",
+    bitcoinRegtest = "regtest"
+}
+export declare enum EAddressType {
+    p2wpkh = "p2wpkh",
+    p2sh = "p2sh",
+    p2pkh = "p2pkh"
+}
+export declare enum EPaymentType {
+    sent = "sent",
+    received = "received"
+}
+export type TAddressTypeContent<T> = {
+    [key in EAddressType]: T;
+};
+export interface IAddressTypeData {
+    type: EAddressType;
+    path: string;
+    name: string;
+    shortName: string;
+    description: string;
+    example: string;
+}
+export interface IUtxo {
+    address: string;
+    index: number;
+    path: string;
+    scriptHash: string;
+    height: number;
+    tx_hash: string;
+    tx_pos: number;
+    value: number;
+}
+export interface IVin {
+    scriptSig: {
+        asm: string;
+        hex: string;
+    };
+    sequence: number;
+    txid: string;
+    txinwitness: string[];
+    vout: number;
+}
+export interface IFormattedTransaction {
+    address: string;
+    height: number;
+    scriptHash: string;
+    totalInputValue: number;
+    matchedInputValue: number;
+    totalOutputValue: number;
+    matchedOutputValue: number;
+    fee: number;
+    satsPerByte: number;
+    type: EPaymentType;
+    value: number;
+    txid: string;
+    messages: string[];
+    vin: IVin[];
+    timestamp: number;
+    confirmTimestamp?: number;
+    exists?: boolean;
+    rbf?: boolean;
+    vsize: number;
+}
+export interface IFormattedTransactions {
+    [key: string]: IFormattedTransaction;
+}
+export interface IOutput {
+    address: string;
+    value: number;
+    index: number;
+}
+export declare enum EBoostType {
+    rbf = "rbf",
+    cpfp = "cpfp"
+}
+export interface ISendTransaction {
+    outputs: IOutput[];
+    inputs: IUtxo[];
+    changeAddress: string;
+    fiatAmount: number;
+    fee: number;
+    satsPerByte: number;
+    selectedFeeId: EFeeId;
+    message: string;
+    label: string;
+    rbf: boolean;
+    boostType: EBoostType;
+    minFee: number;
+    max: boolean;
+    tags: string[];
+    slashTagsUrl?: string;
+    lightningInvoice?: string;
+}
+export interface IAddresses {
+    [scriptHash: string]: IAddress;
+}
+export interface IAddress {
+    index: number;
+    path: string;
+    address: string;
+    scriptHash: string;
+    publicKey: string;
+}
+export interface IWalletData {
+    id: string;
+    addressType: EAddressType;
+    header: IHeader;
+    addresses: TAddressTypeContent<IAddresses>;
+    changeAddresses: TAddressTypeContent<IAddresses>;
+    addressIndex: TAddressTypeContent<IAddress>;
+    changeAddressIndex: TAddressTypeContent<IAddress>;
+    lastUsedAddressIndex: TAddressTypeContent<IAddress>;
+    lastUsedChangeAddressIndex: TAddressTypeContent<IAddress>;
+    utxos: IUtxo[];
+    blacklistedUtxos: IUtxo[];
+    unconfirmedTransactions: IFormattedTransactions;
+    transactions: IFormattedTransactions;
+    boostedTransactions: IBoostedTransactions;
+    transaction: ISendTransaction;
+    balance: number;
+    selectedFeeId: EFeeId;
+    exchangeRates: IExchangeRates;
+    feeEstimates: IOnchainFees;
+}
+export type TWalletDataKeys = keyof IWalletData;
+export type TGetData = <K extends keyof IWalletData>(key: string) => Promise<Result<IWalletData[K]>>;
+export type TSetData = <K extends keyof IWalletData>(key: string, value: IWalletData[K]) => Promise<Result<boolean>>;
+export interface IWallet {
+    mnemonic: string;
+    id?: string;
+    name?: string;
+    passphrase?: string;
+    network?: EAvailableNetworks;
+    addressType?: EAddressType;
+    data?: IWalletData;
+    storage?: TStorage;
+    electrumOptions?: {
+        servers?: TServer | TServer[];
+        tls?: TLSSocket;
+        net?: Server;
+    };
+    remainOffline?: boolean;
+    onMessage?: TOnMessage;
+    customGetAddress?: (data: ICustomGetAddress) => Promise<Result<IGetAddressResponse>>;
+    customGetScriptHash?: (data: ICustomGetScriptHash) => Promise<string>;
+    rbf?: boolean;
+    selectedFeeId?: EFeeId;
+}
+export interface IAddressData {
+    path: string;
+    type: 'p2wpkh' | 'p2sh' | 'p2pkh';
+    label: string;
+}
+export interface IAddressType {
+    [key: string]: IAddressData;
+}
+export interface IKeyDerivationPath {
+    purpose?: TKeyDerivationPurpose;
+    coinType?: TKeyDerivationCoinType;
+    account?: TKeyDerivationAccount;
+    change?: TKeyDerivationChange;
+    index?: TKeyDerivationIndex;
+}
+export interface IGetDerivationPath extends IKeyDerivationPath {
+    addressType?: EAddressType;
+}
+export interface IGetAddress {
+    index?: TKeyDerivationIndex;
+    changeAddress?: boolean;
+    addressType?: EAddressType;
+}
+export interface ICustomGetAddress {
+    path: string;
+    type: EAddressType;
+    selectedNetwork?: TElectrumNetworks;
+}
+export interface ICustomGetScriptHash {
+    address: string;
+    selectedNetwork?: TElectrumNetworks;
+}
+export interface IGetAddressByPath {
+    path: string;
+    addressType?: EAddressType;
+}
+export interface IGetAddressBalanceRes {
+    confirmed: number;
+    unconfirmed: number;
+}
+export interface IUtxo {
+    address: string;
+    index: number;
+    path: string;
+    scriptHash: string;
+    height: number;
+    tx_hash: string;
+    tx_pos: number;
+    value: number;
+}
+export interface IGenerateAddresses {
+    addressAmount?: number;
+    changeAddressAmount?: number;
+    addressIndex?: number;
+    changeAddressIndex?: number;
+    keyDerivationPath?: IKeyDerivationPath;
+    addressType?: EAddressType;
+}
+export interface IKeyDerivationPathData {
+    pathString: string;
+    pathObject: IKeyDerivationPath;
+}
+export interface IGenerateAddressesResponse {
+    addresses: IAddresses;
+    changeAddresses: IAddresses;
+}
+export interface IGetAddressResponse {
+    address: string;
+    path: string;
+    publicKey: string;
+}
+export interface IGetNextAvailableAddressResponse {
+    addressIndex: IAddress;
+    lastUsedAddressIndex: IAddress;
+    changeAddressIndex: IAddress;
+    lastUsedChangeAddressIndex: IAddress;
+}
+export interface ITxHashes extends TTxResult {
+    scriptHash: string;
+}
+export interface IIndexes {
+    addressIndex: IAddress;
+    changeAddressIndex: IAddress;
+    foundAddressIndex: boolean;
+    foundChangeAddressIndex: boolean;
+}
+export interface ITxHash {
+    tx_hash: string;
+}
+export interface IGetTransactions {
+    error: boolean;
+    id: number;
+    method: string;
+    network: string;
+    data: ITransaction<IUtxo>[];
+}
+export interface ITransaction<T> {
+    id: number;
+    jsonrpc: string;
+    param: string;
+    data: T;
+    result: {
+        blockhash: string;
+        confirmations: number;
+        hash: string;
+        hex: string;
+        locktime: number;
+        size: number;
+        txid: string;
+        version: number;
+        vin: IVin[];
+        vout: IVout[];
+        vsize: number;
+        weight: number;
+        blocktime?: number;
+        time?: number;
+    };
+}
+export interface IVout {
+    n: number;
+    scriptPubKey: {
+        addresses?: string[];
+        address?: string;
+        asm: string;
+        hex: string;
+        reqSigs?: number;
+        type?: string;
+    };
+    value: number;
+}
+export type TProcessUnconfirmedTransactions = {
+    unconfirmedTxs: IFormattedTransactions;
+    outdatedTxs: IUtxo[];
+    ghostTxs: string[];
+};
+export declare enum EUnit {
+    satoshi = "satoshi",
+    BTC = "BTC",
+    fiat = "fiat"
+}
+export interface IExchangeRates {
+    [key: string]: {
+        currencySymbol: string;
+        quote: string;
+        quoteName: string;
+        rate: number;
+        lastUpdatedAt: number;
+    };
+}
+export type InputData = {
+    [key: string]: {
+        addresses: string[];
+        value: number;
+    };
+};
+export type TGetByteCountInputs = {
+    [key in TGetByteCountInput]?: number;
+};
+export type TGetByteCountOutputs = {
+    [key in TGetByteCountOutput]?: number;
+};
+export type TGetByteCountInput = `MULTISIG-P2SH:${number}-${number}` | `MULTISIG-P2WSH:${number}-${number}` | `MULTISIG-P2SH-P2WSH:${number}-${number}` | 'P2SH-P2WPKH' | 'P2PKH' | 'p2pkh' | 'P2WPKH' | 'p2wpkh' | 'P2SH' | 'p2sh' | 'P2TR' | 'p2tr';
+export type TGetByteCountOutput = 'P2SH' | 'P2PKH' | 'P2WPKH' | 'P2WSH' | 'p2wpkh' | 'p2sh' | 'p2pkh' | 'P2TR' | 'p2tr';
+export interface IGetFeeEstimatesResponse {
+    fastestFee: number;
+    halfHourFee: number;
+    hourFee: number;
+    minimumFee: number;
+}
+export interface IOnchainFees {
+    fast: number;
+    normal: number;
+    slow: number;
+    minimum: number;
+    timestamp: number;
+}
+export type TMessageDataMap = {
+    newBlock: INewBlock;
+    transactionReceived: TTransactionMessage;
+    transactionConfirmed: TTransactionMessage;
+    transactionSent: TTransactionMessage;
+    reorg: IUtxo[];
+    rbf: string[];
+    connectedToElectrum: boolean;
+};
+export type TTransactionMessage = {
+    transaction: IFormattedTransaction;
+};
+export type ObjectKeys<T extends object> = `${Exclude<keyof T, symbol>}`;
+export type TOnMessage = <K extends keyof TMessageDataMap>(key: K, data: TMessageDataMap[K]) => void;
+export type TMessageKeys = keyof TMessageDataMap;
+export interface ISendTx {
+    address: string;
+    amount: number;
+    message?: string;
+}
+export interface ISend {
+    txs: ISendTx | ISendTx[];
+    satsPerByte?: number;
+}
+export type TAddressIndexInfo = {
+    addressIndex: IAddress;
+    changeAddressIndex: IAddress;
+    lastUsedAddressIndex: IAddress;
+    lastUsedChangeAddressIndex: IAddress;
+};
+export type TStorage = {
+    getData?: TGetData;
+    setData?: TSetData;
+};
+export interface IRbfData {
+    outputs: IOutput[];
+    balance: number;
+    addressType: EAddressType;
+    fee: number;
+    inputs: IUtxo[];
+    message: string;
+}
+export interface IBoostedTransaction {
+    parentTransactions: string[];
+    childTransaction: string;
+    type: EBoostType;
+    fee: number;
+}
+export interface IBoostedTransactions {
+    [txId: string]: IBoostedTransaction;
+}

package/dist/types/utils/conversion.d.ts

@@ -0,0 +1,10 @@
+import { EUnit } from '../types';
+export declare const btcToSats: (value: number) => number;
+export declare const satsToBtc: (value: number) => number;
+export declare const convertToSats: (value: number | string, unit: EUnit, exchangeRate: number, currency?: string) => number;
+export declare const fiatToBitcoinUnit: ({ fiatValue, exchangeRate, currency, unit }: {
+    fiatValue: string | number;
+    exchangeRate: number;
+    currency: string;
+    unit: EUnit;
+}) => number;

package/dist/types/utils/derivation-path.d.ts

@@ -0,0 +1,19 @@
+import { EAddressType, EAvailableNetworks, IKeyDerivationPath, TKeyDerivationPurpose } from '../types';
+import { Result } from './result';
+export declare const getKeyDerivationPathObject: ({ path, purpose, changeAddress, index, network }: {
+    path: string;
+    purpose?: string | undefined;
+    changeAddress?: boolean | undefined;
+    index?: string | undefined;
+    network: EAvailableNetworks;
+}) => Result<IKeyDerivationPath>;
+export declare const getKeyDerivationPathString: ({ addressType, path, purpose, accountType, changeAddress, index, network }: {
+    addressType: EAddressType;
+    path?: IKeyDerivationPath | undefined;
+    purpose?: string | undefined;
+    accountType?: string | number | undefined;
+    changeAddress?: boolean | undefined;
+    index?: string | number | undefined;
+    network: EAvailableNetworks;
+}) => Result<string>;
+export declare const getAddressTypeFromPath: (path: string | IKeyDerivationPath) => Result<EAddressType>;

package/dist/types/utils/electrum.d.ts

@@ -0,0 +1,10 @@
+import { Result } from './result';
+import { EAvailableNetworks, ElectrumConnectionPubSub, IFormattedPeerData, TProtocol } from '../types';
+export declare const defaultElectrumPorts: string[];
+export declare const getDefaultPort: (selectedNetwork: EAvailableNetworks, protocol: TProtocol) => number;
+export declare const getProtocolForPort: (port: string, network: EAvailableNetworks) => TProtocol | undefined;
+export declare const formatPeerData: (data: [string, string, [string, string, string]]) => Result<IFormattedPeerData>;
+export declare const getPeers: ({ selectedNetwork }: {
+    selectedNetwork: EAvailableNetworks;
+}) => Promise<Result<IFormattedPeerData[]>>;
+export declare const electrumConnection: ElectrumConnectionPubSub;

package/dist/types/utils/exchange-rate.d.ts

@@ -0,0 +1,30 @@
+import { Result } from './result';
+import { IExchangeRates } from '../types';
+export declare const mostUsedExchangeTickers: {
+    USD: {
+        currencySymbol: string;
+        quote: string;
+        quoteName: string;
+    };
+    GBP: {
+        currencySymbol: string;
+        quote: string;
+        quoteName: string;
+    };
+    CAD: {
+        currencySymbol: string;
+        quote: string;
+        quoteName: string;
+    };
+    CNY: {
+        currencySymbol: string;
+        quote: string;
+        quoteName: string;
+    };
+    EUR: {
+        currencySymbol: string;
+        quote: string;
+        quoteName: string;
+    };
+};
+export declare const getExchangeRates: () => Promise<Result<IExchangeRates>>;

package/dist/types/utils/helpers.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import { EAddressType, EAvailableNetworks, IKeyDerivationPath } from '../types';
+import { Result } from './result';
+export declare const getAddressFromScriptPubKey: (scriptPubKey: string, selectedNetwork: EAvailableNetworks) => string;
+export declare const getSha256: (str: string) => string;
+export declare const validateAddress: ({ address, network }: {
+    address: string;
+    network?: EAvailableNetworks | undefined;
+}) => {
+    isValid: boolean;
+    network: EAvailableNetworks;
+};
+export declare const getKeyDerivationPath: ({ addressType, network }: {
+    addressType: EAddressType;
+    network: EAvailableNetworks;
+}) => Result<IKeyDerivationPath>;
+export declare const getScriptHash: ({ address, network }: {
+    address: string;
+    network: EAvailableNetworks;
+}) => string;
+export declare const generateMnemonic: (strength?: number, rng?: ((size: number) => Buffer) | undefined, wordlist?: string[]) => string;
+export declare const validateMnemonic: (mnemonic?: string) => boolean;
+export declare const objectsMatch: (obj1: any, obj2: any) => boolean;

package/dist/types/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * from './wallet';
+export * from './helpers';
+export * from './exchange-rate';
+export * from './electrum';
+export * from './derivation-path';
+export * from './transaction';
+export * from './result';

package/dist/types/utils/result.d.ts

@@ -0,0 +1,16 @@
+export type Result<T> = Ok<T> | Err<T>;
+declare class Ok<T> {
+    readonly value: T;
+    constructor(value: T);
+    isOk(): this is Ok<T>;
+    isErr(): this is Err<T>;
+}
+declare class Err<T> {
+    readonly error: Error;
+    constructor(error: Error);
+    isOk(): this is Ok<T>;
+    isErr(): this is Err<T>;
+}
+export declare const ok: <T>(value: T) => Ok<T>;
+export declare const err: <T>(error: Error | string) => Err<T>;
+export {};

package/dist/types/utils/transaction.d.ts

@@ -0,0 +1,21 @@
+import { Psbt } from 'bitcoinjs-lib';
+import { Result } from './result';
+import { EAddressType, EAvailableNetworks, IOutput, ISendTransaction, TDecodeRawTx, TGetByteCountInputs, TGetByteCountOutputs } from '../types';
+export declare const setReplaceByFee: ({ psbt, setRbf }: {
+    psbt: Psbt;
+    setRbf: boolean;
+}) => void;
+export declare const parseOnChainPaymentRequest: (data: string, network?: EAvailableNetworks) => Result<{
+    address: string;
+    network: EAvailableNetworks;
+    sats: number;
+    message: string;
+}>;
+export declare const constructByteCountParam: (addresses: string[], increaseAddressCount?: {
+    addrType: EAddressType;
+    count: number;
+}[]) => TGetByteCountInputs | TGetByteCountOutputs;
+export declare const getByteCount: (inputs: TGetByteCountInputs, outputs: TGetByteCountOutputs, message?: string) => number;
+export declare const removeDustOutputs: (outputs: IOutput[]) => IOutput[];
+export declare const validateTransaction: (transaction: ISendTransaction) => Result<string>;
+export declare const decodeRawTransaction: (hex: string, _network: EAvailableNetworks) => Result<TDecodeRawTx>;

package/dist/types/utils/wallet.d.ts

@@ -0,0 +1,47 @@
+/// <reference types="node" />
+import { EAddressType, EAvailableNetworks, IAddress, IAddresses, IIndexes, IKeyDerivationPath, IKeyDerivationPathData, ITxHashes, IWalletData, ObjectKeys, TGetData, TKeyDerivationPurpose } from '../types';
+import { Result } from './result';
+export declare const getDefaultWalletData: () => IWalletData;
+export declare const getDefaultWalletDataKeys: () => (keyof IWalletData)[];
+export declare const getKeyValue: (key: string) => string;
+export declare const objectKeys: <Type extends object>(value: Type) => `${Exclude<keyof Type, symbol>}`[];
+export declare const formatKeyDerivationPath: ({ path, purpose, network, changeAddress, index, addressType }: {
+    path: IKeyDerivationPath | string;
+    purpose?: string | undefined;
+    network: EAvailableNetworks;
+    changeAddress?: boolean | undefined;
+    index?: string | undefined;
+    addressType?: EAddressType | undefined;
+}) => Result<IKeyDerivationPathData>;
+export declare const getHighestUsedIndexFromTxHashes: ({ txHashes, addresses, changeAddresses, addressIndex, changeAddressIndex }: {
+    txHashes: ITxHashes[];
+    addresses: IAddresses;
+    changeAddresses: IAddresses;
+    addressIndex: IAddress;
+    changeAddressIndex: IAddress;
+}) => Result<IIndexes>;
+export declare const isValidBech32mEncodedString: (address: string) => {
+    isValid: boolean;
+    network: EAvailableNetworks;
+};
+export declare const availableNetworks: () => EAvailableNetworks[];
+export declare const reduceValue: <T>({ arr, value }: {
+    arr: T[];
+    value: keyof T;
+}) => Result<number>;
+export declare const shuffleArray: <T>(array: T[]) => T[];
+export declare const getDataFallback: TGetData;
+export declare const decodeOpReturnMessage: (opReturn?: string) => string[];
+export declare const getSeed: (mnemonic: any, bip39Passphrase: any) => Buffer;
+export declare const getSeedHash: (seed: Buffer) => string;
+export declare const generateWalletId: (seed: Buffer) => string;
+export declare const getWalletDataStorageKey: (name: string, network: EAvailableNetworks, key: keyof IWalletData) => string;
+export declare const getStorageKeyValues: (storageKey: string) => {
+    walletName: string;
+    network: EAvailableNetworks;
+    value: keyof IWalletData;
+};
+export declare const getTxFee: ({ satsPerByte, transactionByteCount }: {
+    satsPerByte: number;
+    transactionByteCount: number;
+}) => number;

package/dist/types/wallet/constants.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+export declare const BITKIT_WALLET_SEED_HASH_PREFIX: Buffer;
+export declare const WALLET_ID_PREFIX: Buffer;
+export declare const GENERATE_ADDRESS_AMOUNT = 5;
+export declare const GAP_LIMIT = 20;
+export declare const CHUNK_LIMIT = 15;
+export declare const SPENDING_LIMIT_RATIO = 0.8;
+export declare const TRANSACTION_DEFAULTS: {
+    recommendedBaseFee: number;
+    dustLimit: number;
+};
+export declare const BLOCKTANK_HOST = "https://api.stag.blocktank.to";