bitgo

  • Version 13.1.0
  • Published
  • 85 MB
  • 39 dependencies
  • Apache-2.0 license

Install

npm i bitgo
yarn add bitgo
pnpm add bitgo

Overview

BitGo Javascript SDK

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable Environments

const Environments: common.Environments;

    variable GlobalCoinFactory

    const GlobalCoinFactory: CoinFactory;

      variable sjcl

      const sjcl: any;
      • Deprecated

      Functions

      function getNetwork

      getNetwork: () => import('./v2').V1Network;
      • Get the network. Returns either "bitcoin" or "testnet".

        Deprecated

      function getNetworkObj

      getNetworkObj: () => any;
      • Deprecated

      function setNetwork

      setNetwork: (network: any) => void;
      • Set the network, i.e. either "bitcoin" for production with real bitcoin, or "testnet" for development with testnet bitcoin.

        Deprecated

      Classes

      class BaseCoin

      abstract class BaseCoin {}

        constructor

        protected constructor(bitgo: BitGo);

          property bitgo

          protected readonly bitgo: BitGo;

            property coinTokenPatternSeparator

            static readonly coinTokenPatternSeparator: string;

              property type

              readonly type: string;

                method allowsAccountConsolidations

                allowsAccountConsolidations: () => boolean;
                • Flag for determining whether this coin supports account consolidations from its receive addresses to the root address.

                  Returns

                  {boolean} True if okay to consolidate over this coin; false, otherwise

                method baseUnitsToBigUnits

                baseUnitsToBigUnits: (baseUnits: string | number) => string;
                • Convert a currency amount represented in base units (satoshi, wei, atoms, drops, stroops) to big units (btc, eth, xrp, xlm)

                method bigUnitsToBaseUnits

                bigUnitsToBaseUnits: (bigUnits: string | number) => string;
                • Convert a currency amount represented in big units (btc, eth, xrp, xlm) to base units (satoshi, wei, atoms, drops, stroops)

                  Parameter bigUnits

                method canonicalAddress

                canonicalAddress: (address: string, format?: unknown) => string;
                • convert address into desired address format.

                  Parameter address

                  Parameter format

                method deriveKeyWithSeed

                deriveKeyWithSeed: ({ key, seed }: { key: string; seed: string }) => {
                key: string;
                derivationPath: string;
                };
                • The cold wallet tool uses this function to derive an extended key that is based on the passed key and seed

                  Parameter key

                  Parameter seed

                  Returns

                  {{key: string, derivationPath: string}}

                method enterprises

                enterprises: () => Enterprises;

                  method feeEstimate

                  feeEstimate: (
                  params: FeeEstimateOptions,
                  callback?: NodeCallback<any>
                  ) => Bluebird<any>;
                  • Fetch fee estimate information from the server

                    Parameter params

                    The params passed into the function

                    Parameter

                    {Integer} params.numBlocks The number of blocks to target for conformation (Only works for btc)

                    Parameter callback

                    Returns

                    {Object} The info returned from the merchant server

                  method generateKeyPair

                  abstract generateKeyPair: (seed?: Buffer) => KeyPair;
                  • Generate a key pair on the curve used by the coin

                    Parameter seed

                  method getBaseFactor

                  abstract getBaseFactor: () => number | string;
                  • Returns the factor between the base unit and its smallest subdivison {number}

                  method getChain

                  abstract getChain: () => string;
                  • Name of the chain which supports this coin (eg, 'btc', 'eth')

                  method getExtraPrebuildParams

                  getExtraPrebuildParams: (
                  buildParams: ExtraPrebuildParamsOptions,
                  callback?: NodeCallback<Record<string, unknown>>
                  ) => Bluebird<Record<string, unknown>>;
                  • Get extra parameters for prebuilding a tx. Add things like hop transaction params

                  method getFamily

                  abstract getFamily: () => string;
                  • Name of the coin family (eg. for tbtc, this would be btc)

                  method getFullName

                  abstract getFullName: () => string;
                  • Human readable full name for the coin

                  method initiateRecovery

                  initiateRecovery: (params: InitiateRecoveryOptions) => never;
                  • Deprecated

                    - use getBip32Keys() in conjunction with isValidAddress instead

                  method isValidAddress

                  abstract isValidAddress: (address: string) => boolean;
                  • Check if address is a plausibly valid address for the given coin.

                    Does not verify that the address belongs to a wallet. For that, use [[verifyAddress]]

                    Parameter address

                  method isValidMofNSetup

                  isValidMofNSetup: ({ m, n }: { m?: number; n?: number }) => boolean;
                  • Return wether the given m of n wallet signers/ key amounts are valid for the coin

                  method isValidPub

                  abstract isValidPub: (pub: string) => boolean;
                  • Return boolean indicating whether input is valid public key for the coin.

                    Parameter pub

                    the pub to be checked

                    Returns

                    {Boolean} is it valid?

                  method keychains

                  keychains: () => Keychains;

                    method keyIdsForSigning

                    keyIdsForSigning: () => number[];
                    • Specifies what key we will need for signing - right now we just need the user key.

                    method markets

                    markets: () => Markets;

                      method newWalletObject

                      newWalletObject: (walletParams: any) => Wallet;
                      • Create a new wallet object from a wallet data object

                        Parameter walletParams

                      method parseTransaction

                      abstract parseTransaction: (
                      params: ParseTransactionOptions,
                      callback?: NodeCallback<ParsedTransaction>
                      ) => Bluebird<ParsedTransaction>;

                        method pendingApprovals

                        pendingApprovals: () => PendingApprovals;

                          method postProcessPrebuild

                          postProcessPrebuild: (
                          prebuildResponse: TransactionPrebuild,
                          callback?: NodeCallback<TransactionPrebuild>
                          ) => Bluebird<TransactionPrebuild>;
                          • Modify prebuild after receiving it from the server. Add things like nlocktime

                          method preCreateBitGo

                          preCreateBitGo: (params: PrecreateBitGoOptions) => void;
                          • Perform additional checks before adding a bitgo key. Base controller is a no-op, but coin-specific controller may do something

                            Parameter params

                          method presignTransaction

                          presignTransaction: (
                          params: PresignTransactionOptions,
                          callback?: NodeCallback<TransactionPrebuild>
                          ) => Bluebird<TransactionPrebuild>;
                          • Coin-specific things done before signing a transaction, i.e. verification

                          method signMessage

                          signMessage: (
                          key: { prv: string },
                          message: string,
                          callback?: NodeCallback<Buffer>
                          ) => Bluebird<Buffer>;
                          • Sign message with private key

                            Parameter key

                            Parameter message

                            Parameter callback

                          method signTransaction

                          abstract signTransaction: (
                          params: SignTransactionOptions
                          ) => Promise<SignedTransaction>;
                          • Sign a transaction

                          method supplementGenerateWallet

                          supplementGenerateWallet: (
                          walletParams: SupplementGenerateWalletOptions,
                          keychains: KeychainsTriplet
                          ) => Bluebird<any>;
                          • Hook to add additional parameters to the wallet generation

                            Parameter walletParams

                            Parameter keychains

                            {*}

                          method supportsBlockTarget

                          supportsBlockTarget: () => boolean;
                          • Check whether a coin supports blockTarget for transactions to be included in

                            Returns

                            {boolean}

                          method transactionDataAllowed

                          transactionDataAllowed: () => boolean;
                          • Flag for sending data along with transactions

                            Returns

                            {boolean} True if okay to send tx data (ETH), false otherwise

                          method url

                          url: (suffix: string) => string;

                            method valuelessTransferAllowed

                            valuelessTransferAllowed: () => boolean;
                            • Flag for sending value of 0.

                              Returns

                              {boolean} True if okay to send 0 value, false otherwise

                            method verifyAddress

                            abstract verifyAddress: (params: VerifyAddressOptions) => boolean;
                            • Verify that an address belongs to a wallet

                              Returns

                              {boolean}

                            method verifyRecoveryTransaction

                            verifyRecoveryTransaction: (
                            txInfo: VerifyRecoveryTransactionOptions
                            ) => Bluebird<any>;

                              method verifyTransaction

                              abstract verifyTransaction: (
                              params: VerifyTransactionOptions,
                              callback?: NodeCallback<boolean>
                              ) => Bluebird<boolean>;
                              • Verify that a transaction prebuild complies with the original intention

                              method wallets

                              wallets: () => Wallets;

                                method webhooks

                                webhooks: () => Webhooks;

                                  class BitGo

                                  class BitGo {}

                                    constructor

                                    constructor(params?: BitGoOptions);
                                    • Constructor for BitGo Object

                                    property env

                                    readonly env: EnvironmentName;
                                    • Expose env property for backwards compatibility

                                      Deprecated

                                    method addAccessToken

                                    addAccessToken: (params: AddAccessTokenOptions) => Promise<any>;
                                    • addAccessToken Add a BitGo API Access Token to the current user account

                                      Parameter params

                                      { id: <id of the token> token: <access token hex string to be used for BitGo API request verification> label: <user-provided label for this token> user: <id of the user on the token> enterprise <id of the enterprise this token is valid for> client: <the auth client that this token belongs to> scope: <list of allowed OAuth scope values> created: <date the token was created> expires: <date the token will expire> origin: <the origin for which this token is valid> isExtensible: <flag indicating if the token can be extended> extensionAddress: <address whose private key's signature is necessary for extensions> unlock: <info for actions that require an unlock before firing> }

                                    method addWebhook

                                    addWebhook: (params: WebhookOptions) => Promise<any>;
                                    • Add new user webhook

                                      Parameter params

                                      Returns

                                      {*}

                                      Deprecated

                                    method authenticate

                                    authenticate: (params: AuthenticateOptions) => Promise<any>;
                                    • Login to the bitgo platform.

                                    method authenticateWithAccessToken

                                    authenticateWithAccessToken: ({ accessToken }: AccessTokenOptions) => void;
                                    • Synchronous method for activating an access token.

                                    method authenticateWithAuthCode

                                    authenticateWithAuthCode: (
                                    params: AuthenticateWithAuthCodeOptions
                                    ) => Promise<any>;
                                    • Login to the bitgo system using an authcode generated via Oauth

                                    method blockchain

                                    blockchain: () => any;
                                    • Get the blockchain object.

                                      Deprecated

                                    method calculateHMAC

                                    calculateHMAC: (key: string, message: string) => string;
                                    • Calculate the HMAC for the given key and message

                                      Parameter key

                                      the key to use for the HMAC

                                      Parameter message

                                      the actual message to HMAC

                                      Returns

                                      {*} - the result of the HMAC operation

                                    method calculateHMACSubject

                                    calculateHMACSubject: ({
                                    urlPath,
                                    text,
                                    timestamp,
                                    statusCode,
                                    method,
                                    }: CalculateHmacSubjectOptions) => string;
                                    • Calculate the subject string that is to be HMAC'ed for a HTTP request or response

                                      Parameter urlPath

                                      request url, including query params

                                      Parameter text

                                      request body text

                                      Parameter timestamp

                                      request timestamp from Date.now()

                                      Parameter statusCode

                                      Only set for HTTP responses, leave blank for requests

                                      Parameter method

                                      request method

                                      Returns

                                      {string}

                                    method calculateMinerFeeInfo

                                    calculateMinerFeeInfo: (params: any) => Promise<any>;
                                    • V1 method for calculating miner fee amounts, given the number and type of transaction inputs, along with a fee rate in satoshis per vkB.

                                      This method should not be used for new code.

                                      Parameter params

                                      {any}

                                      Deprecated

                                    method calculateRequestHeaders

                                    calculateRequestHeaders: ({
                                    url,
                                    text,
                                    token,
                                    method,
                                    }: CalculateRequestHeadersOptions) => RequestHeaders;
                                    • Calculate request headers with HMAC

                                    method calculateRequestHMAC

                                    calculateRequestHMAC: ({
                                    url: urlPath,
                                    text,
                                    timestamp,
                                    token,
                                    method,
                                    }: CalculateRequestHmacOptions) => string;
                                    • Calculate the HMAC for an HTTP request

                                    method changePassword

                                    changePassword: ({
                                    oldPassword,
                                    newPassword,
                                    }: ChangePasswordOptions) => Promise<any>;
                                    • Change the password of the currently logged in user. Also change all v1 and v2 keychain passwords if they match the given oldPassword. Returns nothing on success.

                                      Parameter oldPassword

                                      the current password

                                      Parameter newPassword

                                      the new password

                                    method clear

                                    clear: () => void;
                                    • Clear out all state from this BitGo object, effectively logging out the current user.

                                    method coin

                                    coin: (coinName: string) => BaseCoin;
                                    • Create a basecoin object

                                      Parameter coinName

                                    method decrypt

                                    decrypt: (params?: DecryptOptions) => string;
                                    • Decrypt an encrypted string locally.

                                    method encrypt

                                    encrypt: (params?: EncryptOptions) => string;
                                    • Utility function to encrypt locally.

                                    method estimateFee

                                    estimateFee: (params?: EstimateFeeOptions) => Promise<any>;
                                    • Estimates approximate fee per kb needed for a tx to get into a block

                                      Parameter

                                      {number} params.numBlocks target blocks for the transaction to be confirmed

                                      Parameter

                                      {number} params.maxFee maximum fee willing to be paid (for safety)

                                      Parameter

                                      {array[string]} params.inputs list of unconfirmed txIds from which this transaction uses inputs

                                      Parameter

                                      {number} params.txSize estimated transaction size in bytes, optional parameter used for CPFP estimation.

                                      Parameter

                                      {boolean} params.cpfpAware flag indicating fee should take into account CPFP

                                      Deprecated

                                    method extendToken

                                    extendToken: (params?: ExtendTokenOptions) => Promise<any>;
                                    • Extend token, provided the current token is extendable

                                      Parameter params

                                      duration: duration in seconds by which to extend the token, starting at the current time

                                    method fetchConstants

                                    fetchConstants: () => Promise<any>;
                                    • Fetch useful constant values from the BitGo server. These values do change infrequently, so they need to be fetched, but are unlikely to change during the lifetime of a BitGo object, so they can safely cached.

                                    method fromJSON

                                    fromJSON: (json: BitGoJson) => void;
                                    • Deserialize a JSON serialized BitGo object.

                                      Overwrites the properties on the current BitGo object with those of the deserialzed object.

                                      Parameter json

                                    method generateRandomPassword

                                    generateRandomPassword: (numWords?: number) => string;
                                    • Generate a random password

                                      Parameter numWords

                                      Number of 32-bit words

                                      Returns

                                      {String} base58 random password

                                    method getAuthVersion

                                    getAuthVersion: () => number;
                                    • Return the current auth version used for requests to the BitGo server

                                    method getBitGoFeeAddress

                                    getBitGoFeeAddress: () => Promise<any>;
                                    • Get a target address for payment of a BitGo fee

                                      Deprecated

                                    method getConstants

                                    getConstants: () => any;
                                    • Synchronously get constants which are relevant to the client.

                                      Note: This function has a known race condition. It may return different values over time, especially if called shortly after creation of the BitGo object.

                                      New code should call fetchConstants() directly instead.

                                      Deprecated

                                      {Object} The client constants object

                                    method getECDHSecret

                                    getECDHSecret: ({ otherPubKeyHex, eckey }: GetEcdhSecretOptions) => string;
                                    • Deprecated

                                      - use getSharedSecret()

                                    method getECDHSharingKeychain

                                    getECDHSharingKeychain: () => Promise<any>;
                                    • Gets the user's private keychain, used for receiving shares

                                    method getEnv

                                    getEnv: () => EnvironmentName;
                                    • Return the current BitGo environment

                                    method getSharingKey

                                    getSharingKey: ({ email }: GetSharingKeyOptions) => Promise<any>;
                                    • Get a key for sharing a wallet with a user

                                      Parameter email

                                      email of user to share wallet with

                                    method getUser

                                    getUser: ({ id }: GetUserOptions) => Promise<any>;
                                    • Get a user by ID (name/email only)

                                      Parameter id

                                      Deprecated

                                    method getValidate

                                    getValidate: () => boolean;

                                    method getWalletAddress

                                    getWalletAddress: ({ address }: { address: string }) => Promise<any>;
                                    • Gets an address object (including the wallet id) for a given address.

                                      Parameter

                                      {string} params.address The address to look up.

                                      Deprecated

                                    method handleTokenIssuance

                                    handleTokenIssuance: (
                                    responseBody: TokenIssuanceResponse,
                                    password?: string
                                    ) => TokenIssuance;
                                    • Parameter responseBody

                                      Response body object

                                      Parameter password

                                      Password for the symmetric decryption

                                    method instantGuarantee

                                    instantGuarantee: (params: { id: string }) => Promise<any>;
                                    • Get BitGo's guarantee using an instant id

                                      Parameter params

                                      Deprecated

                                    method keychains

                                    keychains: () => any;
                                    • Get the user's keychains object.

                                      Deprecated

                                    method labels

                                    labels: () => Promise<any>;
                                    • Get all the address labels on all of the user's wallets

                                      Deprecated

                                    method listAccessTokens

                                    listAccessTokens: () => Promise<any>;
                                    • listAccessTokens Get information on all of the BitGo access tokens on the user { id: <id of the token> label: <the user-provided label for this token> user: <id of the user on the token> enterprise <id of the enterprise this token is valid for> client: <the auth client that this token belongs to> scope: <list of allowed OAuth scope values> created: <date the token was created> expires: <date the token will expire> origin: <the origin for which this token is valid> isExtensible: <flag indicating if the token can be extended> extensionAddress: <address whose private key's signature is necessary for extensions> unlock: <info for actions that require an unlock before firing> }

                                    method listWebhookNotifications

                                    listWebhookNotifications: (
                                    params?: ListWebhookNotificationsOptions
                                    ) => Promise<any>;
                                    • Fetch list of webhook notifications for the user

                                      Parameter params

                                      Returns

                                      {*}

                                    method listWebhooks

                                    listWebhooks: () => Promise<any>;
                                    • Fetch list of user webhooks

                                      Returns

                                      {*}

                                      Deprecated

                                    method lock

                                    lock: () => Promise<any>;
                                    • Lock the session

                                    method logout

                                    logout: () => Promise<any>;
                                    • Logout of BitGo

                                    method market

                                    market: () => Promise<any>;
                                    • Get the latest bitcoin prices (Deprecated: Will be removed in the future) use bitgo.markets().latest()

                                      Deprecated

                                    method markets

                                    markets: () => any;
                                    • Get bitcoin market data

                                      Deprecated

                                    method me

                                    me: () => Promise<any>;
                                    • Get the current logged in user

                                    method microservicesUrl

                                    microservicesUrl: (path: string) => string;
                                    • Create a url for calling BitGo microservice APIs

                                    method newWalletObject

                                    newWalletObject: (walletParams: any) => any;
                                    • A factory method to create a new Wallet object, initialized with the wallet params Can be used to reconstitute a wallet from cached data

                                      Parameter walletParams

                                      Deprecated

                                    method pendingApprovals

                                    pendingApprovals: () => any;
                                    • Get pending approvals that can be approved/ or rejected

                                      Deprecated

                                    method ping

                                    ping: ({ reqId }?: PingOptions) => Promise<any>;
                                    • Test connectivity to the server

                                      Parameter params

                                    method preprocessAuthenticationParams

                                    preprocessAuthenticationParams: ({
                                    username,
                                    password,
                                    otp,
                                    forceSMS,
                                    extensible,
                                    trust,
                                    }: AuthenticateOptions) => ProcessedAuthenticationOptions;
                                    • Process the username, password and otp into an object containing the username and hashed password, ready to send to bitgo for authentication.

                                    method reconstituteSecret

                                    reconstituteSecret: ({
                                    shards,
                                    passwords,
                                    }: ReconstituteSecretOptions) => ReconstitutedSecret;
                                    • Reconstitute a secret which was sharded with splitSecret.

                                      Parameter shards

                                      Parameter passwords

                                    method refreshToken

                                    refreshToken: (params?: { refreshToken?: string }) => Promise<any>;
                                    • Use refresh token to get new access token. If the refresh token is null/defined, then we use the stored token from auth

                                    method registerPushToken

                                    registerPushToken: (params: RegisterPushTokenOptions) => Promise<any>;
                                    • Parameter params

                                      operatingSystem: one of ios, android - pushToken: hex-formatted token for the respective native push notification service

                                      Returns

                                      {*}

                                      Deprecated

                                    method removeAccessToken

                                    removeAccessToken: ({ id, label }: RemoveAccessTokenOptions) => Promise<any>;
                                    • Sets the expire time of an access token matching either the id or label to the current date, effectively deleting it

                                      Params: id: <id of the access token to be deleted> label: <label of the access token to be deleted>

                                      Returns: id: <id of the token> label: <user-provided label for this token> user: <id of the user on the token> enterprise <id of the enterprise this token is valid for> client: <the auth client that this token belongs to> scope: <list of allowed OAuth scope values> created: <date the token was created> expires: <date the token will expire> origin: <the origin for which this token is valid> isExtensible: <flag indicating if the token can be extended> extensionAddress: <address whose private key's signature is ne*cessary for extensions> unlock: <info for actions that require an unlock before firing>

                                      Parameter params

                                    method removeWebhook

                                    removeWebhook: (params: WebhookOptions) => Promise<any>;
                                    • Remove user webhook

                                      Parameter params

                                      Returns

                                      {*}

                                      Deprecated

                                    method sendOTP

                                    sendOTP: (params?: { forceSMS?: boolean }) => Promise<any>;
                                    • Trigger a push/sms for the OTP code

                                      Parameter

                                      {boolean} params.forceSMS If set to true, will use SMS to send the OTP to the user even if they have other 2FA method set up.

                                      Deprecated

                                    method session

                                    session: () => Promise<any>;
                                    • Get the current session

                                    method setRequestTracer

                                    setRequestTracer: (reqTracer: IRequestTracer) => void;
                                    • Set a request tracer to provide request IDs during multi-request workflows

                                    method setValidate

                                    setValidate: (validate: boolean) => void;

                                    method simulateWebhook

                                    simulateWebhook: (params: BitGoSimulateWebhookOptions) => Promise<any>;
                                    • Simulate a user webhook

                                      Parameter params

                                      Returns

                                      {*}

                                    method splitSecret

                                    splitSecret: ({ seed, passwords, m }: SplitSecretOptions) => SplitSecret;
                                    • Split a secret into shards using Shamir Secret Sharing.

                                      Parameter seed

                                      A hexadecimal secret to split

                                      Parameter passwords

                                      An array of the passwords used to encrypt each share

                                      Parameter m

                                      The threshold number of shards necessary to reconstitute the secret

                                    method toJSON

                                    toJSON: () => BitGoJson;
                                    • Serialize this BitGo object to a JSON object.

                                      Caution: contains sensitive data

                                    method token

                                    token: (
                                    tokenName: string,
                                    callback?: NodeCallback<BaseCoin>
                                    ) => Bluebird<BaseCoin>;
                                    • Create a basecoin object for a virtual token

                                      Parameter tokenName

                                      Parameter callback

                                    method travelRule

                                    travelRule: () => any;
                                    • Get the travel rule object

                                      Deprecated

                                    method unlock

                                    unlock: ({ otp, duration }: UnlockOptions) => Promise<any>;
                                    • Unlock the session by providing OTP

                                      Parameter otp

                                      Required OTP code for the account.

                                      Parameter duration

                                      Desired duration of the unlock in seconds (default=600, max=3600).

                                    method url

                                    url: (path: string, version?: number) => string;
                                    • Create a url for calling BitGo platform APIs

                                      Parameter path

                                      Parameter version

                                    method user

                                    user: () => User | undefined;
                                    • Get the current user

                                    method verifyAddress

                                    verifyAddress: (params?: DeprecatedVerifyAddressOptions) => boolean;
                                    • Verify a Bitcoin address is a valid base58 address

                                      Deprecated

                                    method verifyPassword

                                    verifyPassword: (params?: VerifyPasswordOptions) => Promise<any>;

                                    method verifyPushToken

                                    verifyPushToken: (params: VerifyPushTokenOptions) => Promise<any>;
                                    • Parameter params

                                      pushVerificationToken: the token received via push notification to confirm the device's mobility

                                      Deprecated

                                    method verifyResponse

                                    verifyResponse: ({
                                    url: urlPath,
                                    statusCode,
                                    text,
                                    timestamp,
                                    token,
                                    hmac,
                                    method,
                                    }: VerifyResponseOptions) => VerifyResponseInfo;
                                    • Verify the HMAC for an HTTP response

                                    method verifyShards

                                    verifyShards: ({ shards, passwords, m, xpub }: VerifyShardsOptions) => boolean;
                                    • Parameter shards

                                      Parameter passwords

                                      Parameter m

                                      Parameter xpub

                                      Optional xpub to verify the results against

                                    method version

                                    version: () => string;
                                    • Gets the version of the BitGoJS package

                                    method wallets

                                    wallets: () => any;
                                    • Get the user's wallets object.

                                      Deprecated

                                    method yesterday

                                    yesterday: () => Promise<any>;
                                    • Get market data from yesterday (Deprecated: Will be removed in the future) use bitgo.markets().yesterday()

                                      Deprecated

                                    class CoinFactory

                                    class CoinFactory {}

                                      method getInstance

                                      getInstance: (bitgo: BitGo, name: string) => BaseCoin;
                                      • Parameter bitgo

                                        Parameter name

                                        Throws

                                        CoinNotDefinedError

                                        Throws

                                        UnsupportedCoinError

                                      method registerCoinConstructor

                                      registerCoinConstructor: (name: string, constructor: CoinConstructor) => void;

                                        class Enterprise

                                        class Enterprise {}

                                          constructor

                                          constructor(
                                          bitgo: BitGo,
                                          baseCoin: BaseCoin,
                                          enterpriseData: { id: string; name: string }
                                          );

                                            property id

                                            readonly id: string;

                                              property name

                                              readonly name: string;

                                                method addUser

                                                addUser: (params?: any, callback?: NodeCallback<any>) => Bluebird<any>;
                                                • Add a user to this Enterprise

                                                  Parameter params

                                                  Parameter callback

                                                method affirmations

                                                affirmations: () => Affirmations;
                                                • Manage affirmations for an enterprise

                                                method coinUrl

                                                coinUrl: (query?: string) => string;
                                                • Enterprise URL for v2 methods, such as getting fee address balances

                                                  Parameter query

                                                method coinWallets

                                                coinWallets: (
                                                params?: Record<string, never>,
                                                callback?: NodeCallback<Wallet[]>
                                                ) => Bluebird<Wallet[]>;
                                                • Get the wallets associated with this Enterprise

                                                  Parameter params

                                                  Parameter callback

                                                method getFeeAddressBalance

                                                getFeeAddressBalance: (
                                                params?: Record<string, never>,
                                                callback?: NodeCallback<any>
                                                ) => Bluebird<any>;
                                                • Get the fee address balance for this Enterprise

                                                  Parameter _params

                                                  Parameter callback

                                                method getFirstPendingTransaction

                                                getFirstPendingTransaction: (
                                                params?: Record<string, never>,
                                                callback?: NodeCallback<any>
                                                ) => Bluebird<any>;
                                                • Get the first pending transaction for this Enterprise

                                                  Parameter params

                                                  Parameter callback

                                                method removeUser

                                                removeUser: (params?: any, callback?: NodeCallback<any>) => Bluebird<any>;
                                                • Remove a user from this Enterprise

                                                  Parameter params

                                                  Parameter callback

                                                method settlements

                                                settlements: () => Settlements;
                                                • Manage settlements for an enterprise

                                                method url

                                                url: (query?: string) => string;
                                                • Enterprise URL for v1 methods, such as getting users

                                                  Parameter query

                                                method users

                                                users: (
                                                params?: Record<string, never>,
                                                callback?: NodeCallback<any>
                                                ) => Bluebird<any>;
                                                • Get the users associated with this Enterprise

                                                  Parameter params

                                                  Parameter callback

                                                class Enterprises

                                                class Enterprises {}

                                                  constructor

                                                  constructor(bitgo: BitGo, baseCoin: BaseCoin);

                                                    method create

                                                    create: (
                                                    params?: any,
                                                    callback?: NodeCallback<Enterprise>
                                                    ) => Bluebird<Enterprise>;
                                                    • Create a new enterprise

                                                      Parameter params

                                                      Parameter callback

                                                    method get

                                                    get: (
                                                    params?: GetEnterpriseOptions,
                                                    callback?: NodeCallback<Enterprise>
                                                    ) => Bluebird<Enterprise>;
                                                    • Fetch an enterprise from BitGo

                                                      Parameter params

                                                      Parameter callback

                                                    method list

                                                    list: (
                                                    params?: Record<string, never>,
                                                    callback?: NodeCallback<Enterprise[]>
                                                    ) => Bluebird<Enterprise[]>;
                                                    • List all enterprises available to the current user

                                                      Parameter params

                                                      unused

                                                      Parameter callback

                                                    class Keychains

                                                    class Keychains {}

                                                      constructor

                                                      constructor(bitgo: BitGo, baseCoin: BaseCoin);

                                                        method add

                                                        add: (
                                                        params?: AddKeychainOptions,
                                                        callback?: NodeCallback<Keychain>
                                                        ) => Bluebird<Keychain>;
                                                        • Add a keychain to BitGo's records

                                                          Parameter params

                                                          Parameter callback

                                                        method create

                                                        create: (params?: { seed?: Buffer }) => KeyPair;
                                                        • Create a public/private key pair

                                                          Parameter

                                                          params.seed

                                                        method createBackup

                                                        createBackup: (
                                                        params?: CreateBackupOptions,
                                                        callback?: NodeCallback<Keychain>
                                                        ) => Bluebird<Keychain>;
                                                        • Create a backup key

                                                          Parameter params

                                                          Parameter

                                                          params.provider (optional)

                                                          Parameter callback

                                                        method createBitGo

                                                        createBitGo: (
                                                        params?: CreateBitGoOptions,
                                                        callback?: NodeCallback<Keychain>
                                                        ) => Bluebird<Keychain>;
                                                        • Create a BitGo key

                                                          Parameter params

                                                          (empty)

                                                          Parameter callback

                                                        method get

                                                        get: (
                                                        params: GetKeychainOptions,
                                                        callback?: NodeCallback<Keychain>
                                                        ) => Bluebird<Keychain>;
                                                        • Get a keychain by ID

                                                          Parameter params

                                                          Parameter

                                                          params.id

                                                          Parameter

                                                          params.xpub (optional)

                                                          Parameter

                                                          params.ethAddress (optional)

                                                          Parameter

                                                          params.reqId (optional)

                                                          Parameter callback

                                                        method getKeysForSigning

                                                        getKeysForSigning: (
                                                        params?: GetKeysForSigningOptions,
                                                        callback?: NodeCallback<Keychain[]>
                                                        ) => Bluebird<Keychain[]>;
                                                        • Gets keys for signing from a wallet

                                                          Parameter params

                                                          Parameter callback

                                                          Returns

                                                          {Bluebird[]}

                                                        method list

                                                        list: (
                                                        params?: ListKeychainOptions,
                                                        callback?: NodeCallback<ListKeychainsResult>
                                                        ) => Bluebird<ListKeychainsResult>;
                                                        • list the users keychains

                                                          Parameter params

                                                          Parameter

                                                          params.limit - Max number of results in a single call.

                                                          Parameter

                                                          params.prevId - Continue iterating (provided by nextBatchPrevId in the previous list)

                                                          Parameter callback

                                                          Returns

                                                          {*}

                                                        method updatePassword

                                                        updatePassword: (
                                                        params: UpdatePasswordOptions,
                                                        callback?: NodeCallback<ChangedKeychains>
                                                        ) => Bluebird<ChangedKeychains>;
                                                        • Change the decryption password for all possible keychains associated with a user.

                                                          This function iterates through all keys associated with the user, decrypts them with the old password and re-encrypts them with the new password.

                                                          This should be called when a user changes their login password, and are expecting that their wallet passwords are changed to match the new login password.

                                                          Parameter params

                                                          Parameter

                                                          params.oldPassword - The old password used for encrypting the key

                                                          Parameter

                                                          params.newPassword - The new password to be used for encrypting the key

                                                          Parameter callback

                                                          Returns

                                                          changedKeys Object - e.g.: { xpub1: encryptedPrv, ... }

                                                        method updateSingleKeychainPassword

                                                        updateSingleKeychainPassword: (
                                                        params?: UpdateSingleKeychainPasswordOptions
                                                        ) => Keychain;
                                                        • Update the password used to decrypt a single keychain

                                                          Parameter params

                                                          Parameter

                                                          params.keychain - The keychain whose password should be updated

                                                          Parameter

                                                          params.oldPassword - The old password used for encrypting the key

                                                          Parameter

                                                          params.newPassword - The new password to be used for encrypting the key

                                                          Returns

                                                          {object}

                                                        class Markets

                                                        class Markets {}

                                                          constructor

                                                          constructor(bitgo: BitGo, baseCoin: BaseCoin);

                                                            method lastDays

                                                            lastDays: (
                                                            params: LastDaysOptions,
                                                            callback: NodeCallback<any>
                                                            ) => Bluebird<any>;
                                                            • Get price data from up to 90 days prior to today

                                                              Parameter params

                                                              Parameter callback

                                                              Returns

                                                              {*} an object containing average prices from a number of previous days

                                                            method latest

                                                            latest: (params: LatestOptions, callback: NodeCallback<any>) => Bluebird<any>;
                                                            • Get the latest price data

                                                              Parameter params

                                                              Parameter callback

                                                              Returns

                                                              {*} an object containing price and volume data from the current day in a number of currencies

                                                            method yesterday

                                                            yesterday: (
                                                            params: YesterdayOptions,
                                                            callback: NodeCallback<any>
                                                            ) => Bluebird<any>;
                                                            • Get yesterday's price data

                                                              Parameter params

                                                              Parameter callback

                                                              Returns

                                                              {*} an object containing price and volume data from the previous day in a number of currencies

                                                            class PendingApproval

                                                            class PendingApproval {}

                                                              constructor

                                                              constructor(
                                                              bitgo: BitGo,
                                                              baseCoin: BaseCoin,
                                                              pendingApprovalData: PendingApprovalData,
                                                              wallet?: Wallet
                                                              );

                                                                method approvalsRequired

                                                                approvalsRequired: () => number;
                                                                • Get the number of approvals that are required for this PendingApproval to be approved. Defaults to 1 if approvalsRequired doesn't exist on the object

                                                                method approve

                                                                approve: (
                                                                params?: ApproveOptions,
                                                                callback?: NodeCallback<any>
                                                                ) => Bluebird<any>;
                                                                • Sets this PendingApproval to an approved state

                                                                method cancel

                                                                cancel: (
                                                                params?: Record<string, never>,
                                                                callback?: NodeCallback<any>
                                                                ) => Bluebird<any>;
                                                                • Alias for PendingApproval.reject()

                                                                  Parameter params

                                                                  Parameter callback

                                                                  Deprecated

                                                                method creator

                                                                creator: () => string;
                                                                • Get the id of the user that performed the action resulting in this PendingApproval

                                                                method enterpriseId

                                                                enterpriseId: () => string | undefined;
                                                                • Get the enterprise ID that is associated with this PendingApproval

                                                                method get

                                                                get: (
                                                                params?: Record<string, never>,
                                                                callback?: NodeCallback<PendingApproval>
                                                                ) => Bluebird<PendingApproval>;
                                                                • Refetches this PendingApproval from the server and returns it.

                                                                  Note that this mutates the PendingApproval object in place.

                                                                  Parameter params

                                                                  Parameter callback

                                                                method id

                                                                id: () => string;
                                                                • Get the id for this PendingApproval

                                                                method info

                                                                info: () => PendingApprovalInfo;
                                                                • Get information about this PendingApproval

                                                                method ownerType

                                                                ownerType: () => OwnerType;
                                                                • Get the owner type (wallet or enterprise) Pending approvals can be approved or modified by different scopes (depending on how they were created) If a pending approval is owned by a wallet, then it can be approved by administrators of the wallet If a pending approval is owned by an enterprise, then it can be approved by administrators of the enterprise

                                                                method recreateAndSignTransaction

                                                                recreateAndSignTransaction: (
                                                                params?: any,
                                                                callback?: NodeCallback<any>
                                                                ) => Bluebird<any>;
                                                                • Recreate a transaction for a pending approval to respond to updated network conditions

                                                                  Parameter params

                                                                  Parameter callback

                                                                method reject

                                                                reject: (
                                                                params?: Record<string, never>,
                                                                callback?: NodeCallback<any>
                                                                ) => Bluebird<any>;
                                                                • Sets this PendingApproval to a rejected state

                                                                  Parameter params

                                                                  Parameter callback

                                                                method state

                                                                state: () => State;
                                                                • Get the state of this PendingApproval

                                                                method type

                                                                type: () => Type;
                                                                • Get the type of the pending approval (what it approves)

                                                                method url

                                                                url: (extra?: string) => string;
                                                                • Generate a url for this PendingApproval for making requests to the server.

                                                                  Parameter extra

                                                                method walletId

                                                                walletId: () => string | undefined;
                                                                • Get the id of the wallet which is associated with this PendingApproval

                                                                class PendingApprovals

                                                                class PendingApprovals {}

                                                                  constructor

                                                                  constructor(bitgo: BitGo, baseCoin: BaseCoin);

                                                                    method get

                                                                    get: (
                                                                    params?: GetPendingApprovalOptions,
                                                                    callback?: NodeCallback<PendingApproval>
                                                                    ) => Bluebird<PendingApproval>;
                                                                    • Fetch an existing pending approval

                                                                      Parameter params

                                                                      Parameter callback

                                                                    method list

                                                                    list: (
                                                                    params?: ListPendingApprovalsOptions,
                                                                    callback?: NodeCallback<ListPendingApprovalsResult>
                                                                    ) => Bluebird<ListPendingApprovalsResult>;
                                                                    • List the pending approvals available to the user

                                                                      Parameter params

                                                                      Parameter callback

                                                                    class Wallet

                                                                    class Wallet {}

                                                                      constructor

                                                                      constructor(bitgo: BitGo, baseCoin: BaseCoin, walletData: any);

                                                                        property baseCoin

                                                                        readonly baseCoin: BaseCoin;

                                                                          property bitgo

                                                                          readonly bitgo: BitGo;

                                                                            method accelerateTransaction

                                                                            accelerateTransaction: (
                                                                            params?: AccelerateTransactionOptions,
                                                                            callback?: NodeCallback<any>
                                                                            ) => Bluebird<any>;
                                                                            • Accelerate a transaction's confirmation using Child-Pays-For-Parent (CPFP)

                                                                              Parameter params

                                                                              Parameter callback

                                                                            method addresses

                                                                            addresses: (
                                                                            params?: AddressesOptions,
                                                                            callback?: NodeCallback<any>
                                                                            ) => Bluebird<any>;
                                                                            • List the addresses for a given wallet

                                                                              Parameter params

                                                                              Parameter callback

                                                                              Returns

                                                                              {*}

                                                                            method addWebhook

                                                                            addWebhook: (
                                                                            params?: ModifyWebhookOptions,
                                                                            callback?: NodeCallback<any>
                                                                            ) => Bluebird<any>;
                                                                            • Add a webhook to this wallet

                                                                              Parameter params

                                                                              Parameter callback

                                                                            method approvalsRequired

                                                                            approvalsRequired: () => number;
                                                                            • Get the number of approvals required for spending funds from this wallet

                                                                            method balance

                                                                            balance: () => number;
                                                                            • Get the current balance of this wallet

                                                                            method balanceString

                                                                            balanceString: () => string;
                                                                            • Get a string representation of the balance of this wallet

                                                                              This is useful when balances have the potential to overflow standard javascript numbers

                                                                            method buildAccountConsolidations

                                                                            buildAccountConsolidations: (
                                                                            params?: BuildConsolidationTransactionOptions,
                                                                            callback?: NodeCallback<PrebuildTransactionResult[]>
                                                                            ) => Bluebird<PrebuildTransactionResult[]>;
                                                                            • Builds a set of consolidation transactions for a wallet.

                                                                              Parameter params

                                                                              consolidateAddresses - these are the on-chain receive addresses we want to pick a consolidation amount from

                                                                              Parameter callback

                                                                            method changeFee

                                                                            changeFee: (
                                                                            params?: ChangeFeeOptions,
                                                                            callback?: NodeCallback<any>
                                                                            ) => Bluebird<any>;
                                                                            • Change the fee on the pending transaction that corresponds to the given txid to the given new fee

                                                                              Parameter params

                                                                              Parameter

                                                                              {String} params.txid The transaction Id corresponding to the transaction whose fee is to be changed

                                                                              Parameter

                                                                              {String} params.fee The new fee to apply to the denoted transaction

                                                                              Parameter callback

                                                                              Returns

                                                                              {String} The transaction ID of the new transaction that contains the new fee rate

                                                                            method coin

                                                                            coin: () => string;
                                                                            • Get the coin identifier for the type of coin this wallet holds

                                                                            method coinSpecific

                                                                            coinSpecific: () => WalletCoinSpecific | undefined;
                                                                            • Get wallet properties which are specific to certain coin implementations

                                                                            method confirmedBalance

                                                                            confirmedBalance: () => number;
                                                                            • Get the confirmed balance of this wallet

                                                                            method confirmedBalanceString

                                                                            confirmedBalanceString: () => string;
                                                                            • Get a string representation of the confirmed balance of this wallet

                                                                              This is useful when balances have the potential to overflow standard javascript numbers

                                                                            method consolidateUnspents

                                                                            consolidateUnspents: (
                                                                            params?: ConsolidateUnspentsOptions,
                                                                            callback?: NodeCallback<any>
                                                                            ) => Bluebird<any>;
                                                                            • Consolidate unspents on a wallet

                                                                              Parameter params

                                                                              parameters object

                                                                              Parameter

                                                                              {String} params.walletPassphrase - the users wallet passphrase

                                                                              Parameter

                                                                              {String} params.xprv - the private key in string form if the walletPassphrase is not available

                                                                              Parameter

                                                                              {Number} params.feeRate - The fee rate to use for the consolidation in satoshis/kB

                                                                              Parameter

                                                                              {Number} params.maxFeeRate - upper limit for feeRate in satoshis/kB

                                                                              Parameter

                                                                              {Number} params.maxFeePercentage - the maximum relative portion that you're willing to spend towards fees

                                                                              Parameter

                                                                              {Number} params.feeTxConfirmTarget - estimate the fees to aim for first confirmation with this number of blocks

                                                                              Parameter

                                                                              {Number} params.minValue - the minimum value of unspents to use in satoshis

                                                                              Parameter

                                                                              {Number} params.maxValue - the maximum value of unspents to use in satoshis

                                                                              Parameter

                                                                              {Number} params.minHeight - the minimum height of unspents on the block chain to use

                                                                              Parameter

                                                                              {Number} params.minConfirms - all selected unspents will have at least this many confirmations

                                                                              Parameter

                                                                              {Boolean} params.enforceMinConfirmsForChange - if true, minConfirms also applies to change outputs

                                                                              Parameter

                                                                              {Number} params.limit for routeName === 'consolidate' params.maxNumInputsToUse for routeName === 'fanout' - maximum number of unspents you want to use in the transaction

                                                                              Parameter

                                                                              {Number} params.numUnspentsToMake - the number of new unspents to make

                                                                              Parameter callback

                                                                            method createAddress

                                                                            createAddress: (
                                                                            params?: CreateAddressOptions,
                                                                            callback?: NodeCallback<any>
                                                                            ) => Bluebird<any>;
                                                                            • Create one or more new address(es) for use with this wallet.

                                                                              If the count field is defined and greater than 1, an object with a single array property named addresses containing count address objects will be returned. Otherwise, a single address object is returned.

                                                                              Parameter params

                                                                              Parameter

                                                                              {Number} params.chain on which the new address should be created

                                                                              Parameter

                                                                              {(Number|String)} params.gasPrice gas price for new address creation, if applicable

                                                                              Parameter

                                                                              {String} params.label label for the new address(es)

                                                                              Parameter

                                                                              {String} params.label label for the new address(es)

                                                                              Parameter

                                                                              {Number} params.count=1 number of new addresses which should be created (maximum 250)

                                                                              Parameter

                                                                              {Number} params.forwarderVersion The version of address to create, if applicable

                                                                              Parameter

                                                                              {Boolean} params.lowPriority Ethereum-specific param to create address using low priority fee address

                                                                              Parameter callback

                                                                            method createPolicyRule

                                                                            createPolicyRule: (
                                                                            params?: CreatePolicyRuleOptions,
                                                                            callback?: NodeCallback<any>
                                                                            ) => Bluebird<any>;
                                                                            • Create a policy rule

                                                                              Parameter params

                                                                              Parameter

                                                                              params.condition condition object

                                                                              Parameter

                                                                              params.action action object

                                                                              Parameter callback

                                                                              Returns

                                                                              {*}

                                                                            method createShare

                                                                            createShare: (
                                                                            params?: CreateShareOptions,
                                                                            callback?: NodeCallback<any>
                                                                            ) => Bluebird<any>;
                                                                            • Send an encrypted wallet share to BitGo.

                                                                              Parameter params

                                                                              Parameter callback

                                                                            method downloadKeycard

                                                                            downloadKeycard: (params?: DownloadKeycardOptions) => void;
                                                                            • Creates and downloads PDF keycard for wallet (requires response from wallets.generateWallet)

                                                                              Note: this is example code and is not the version used on bitgo.com

                                                                              Parameter params

                                                                              * jsPDF - an instance of the jsPDF library * QRCode - an instance of the QRious library * userKeychain - a wallet's private user keychain * backupKeychain - a wallet's private backup keychain * bitgoKeychain - a wallet's private bitgo keychain * passphrase - the wallet passphrase * passcodeEncryptionCode - the encryption secret used for Box D * activationCode - a randomly generated six-digit activation code * walletKeyID - the Key ID used for deriving a cold wallet's signing key * backupKeyID - the Key ID used for deriving a cold wallet's backup key

                                                                              Returns

                                                                              {*}

                                                                            method fanoutUnspents

                                                                            fanoutUnspents: (
                                                                            params?: FanoutUnspentsOptions,
                                                                            callback?: NodeCallback<any>
                                                                            ) => Bluebird<any>;
                                                                            • Fanout unspents on a wallet

                                                                              Parameter params

                                                                              parameters object

                                                                              Parameter

                                                                              {String} params.walletPassphrase - the users wallet passphrase

                                                                              Parameter

                                                                              {String} params.xprv - the private key in string form if the walletPassphrase is not available

                                                                              Parameter

                                                                              {Number} params.minValue - the minimum value of unspents to use

                                                                              Parameter

                                                                              {Number} params.maxValue - the maximum value of unspents to use

                                                                              Parameter

                                                                              {Number} params.minHeight - the minimum height of unspents on the block chain to use

                                                                              Parameter

                                                                              {Number} params.minConfirms - all selected unspents will have at least this many confirmations

                                                                              Parameter

                                                                              {Number} params.maxFeePercentage - the maximum proportion of an unspent you are willing to lose to fees

                                                                              Parameter

                                                                              {Number} params.feeTxConfirmTarget - estimate the fees to aim for first confirmation with this number of blocks

                                                                              Parameter

                                                                              {Number} params.feeRate - The desired fee rate for the transaction in satoshis/kB

                                                                              Parameter

                                                                              {Number} params.maxFeeRate - The max limit for a fee rate in satoshis/kB

                                                                              Parameter

                                                                              {Number} params.maxNumInputsToUse - the number of unspents you want to use in the transaction

                                                                              Parameter

                                                                              {Number} params.numUnspentsToMake - the number of new unspents to make

                                                                              Parameter callback

                                                                            method freeze

                                                                            freeze: (params?: FreezeOptions, callback?: NodeCallback<any>) => Bluebird<any>;
                                                                            • Freeze a given wallet

                                                                              Parameter params

                                                                              Parameter callback

                                                                              Returns

                                                                              {*}

                                                                            method getAddress

                                                                            getAddress: (
                                                                            params?: GetAddressOptions,
                                                                            callback?: NodeCallback<any>
                                                                            ) => Bluebird<any>;
                                                                            • Get a single wallet address by its id

                                                                              Parameter params

                                                                              Parameter callback

                                                                              Returns

                                                                              {*}

                                                                            method getEncryptedUserKeychain

                                                                            getEncryptedUserKeychain: (
                                                                            params?: Record<string, never>,
                                                                            callback?: NodeCallback<any>
                                                                            ) => Bluebird<any>;
                                                                            • Gets the user key chain for this wallet

                                                                              The user key chain is the first keychain of the wallet and usually has the encrypted prv stored on BitGo. Useful when trying to get the users' keychain from the server before decrypting to sign a transaction.

                                                                              Parameter params

                                                                              Parameter callback

                                                                            method getFirstPendingTransaction

                                                                            getFirstPendingTransaction: (
                                                                            params?: Record<string, never>,
                                                                            callback?: NodeCallback<any>
                                                                            ) => Bluebird<any>;
                                                                            • Get transaction metadata for the oldest transaction that is still pending or attempted

                                                                              Parameter params

                                                                              Parameter callback

                                                                              Returns

                                                                              {Object} Object with txid, walletId, tx, and fee (if supported for coin)

                                                                            method getPaymentInfo

                                                                            getPaymentInfo: (
                                                                            params?: { url?: string },
                                                                            callback?: NodeCallback<any>
                                                                            ) => Bluebird<any>;
                                                                            • Fetch info from merchant server

                                                                              Parameter params

                                                                              The params passed into the function

                                                                              Parameter

                                                                              {String} params.url The Url to retrieve info from

                                                                              Parameter callback

                                                                              Returns

                                                                              {Object} The info returned from the merchant server

                                                                              Deprecated

                                                                            method getPrv

                                                                            getPrv: (params?: GetPrvOptions, callback?: NodeCallback<any>) => Bluebird<any>;
                                                                            • Gets the unencrypted private key for this wallet (be careful!) Requires wallet passphrase

                                                                              Parameter params

                                                                              Parameter callback

                                                                            method getTransaction

                                                                            getTransaction: (
                                                                            params?: GetTransactionOptions,
                                                                            callback?: NodeCallback<any>
                                                                            ) => Bluebird<any>;
                                                                            • List the transactions for a given wallet

                                                                              Parameter params

                                                                              txHash the transaction hash to search for

                                                                              Parameter callback

                                                                              Returns

                                                                              {*}

                                                                            method getTransfer

                                                                            getTransfer: (
                                                                            params?: GetTransferOptions,
                                                                            callback?: NodeCallback<any>
                                                                            ) => Bluebird<any>;
                                                                            • Get transfers on this wallet

                                                                              Parameter params

                                                                              Parameter callback

                                                                            method getUserPrv

                                                                            getUserPrv: (params?: GetUserPrvOptions) => string;
                                                                            • Get the user private key from either a derivation or an encrypted keychain

                                                                              Parameter

                                                                              [params.keychain / params.key] (object) or params.prv (string)

                                                                              Parameter

                                                                              params.walletPassphrase (string)

                                                                            method id

                                                                            id: () => string;
                                                                            • Get this wallet's id

                                                                            method keyIds

                                                                            keyIds: () => string[];
                                                                            • Get the public object ids for the keychains on this wallet.

                                                                            method label

                                                                            label: () => string;
                                                                            • Get the label (name) for this wallet

                                                                            method listWebhooks

                                                                            listWebhooks: (
                                                                            params?: PaginationOptions,
                                                                            callback?: NodeCallback<any>
                                                                            ) => Bluebird<any>;
                                                                            • List webhooks on this wallet

                                                                              Parameter params

                                                                              Parameter callback

                                                                            method maximumSpendable

                                                                            maximumSpendable: (
                                                                            params?: MaximumSpendableOptions,
                                                                            callback?: NodeCallback<MaximumSpendable>
                                                                            ) => Bluebird<MaximumSpendable>;
                                                                            • Get the maximum amount you can spend in a single transaction

                                                                              Parameter params

                                                                              parameters object

                                                                              Parameter

                                                                              {Number} params.limit - maximum number of selectable unspents

                                                                              Parameter

                                                                              {Number} params.minValue - the minimum value of unspents to use in satoshis

                                                                              Parameter

                                                                              {Number} params.maxValue - the maximum value of unspents to use in satoshis

                                                                              Parameter

                                                                              {Number} params.minHeight - the minimum height of unspents on the block chain to use

                                                                              Parameter

                                                                              {Number} params.minConfirms - all selected unspents will have at least this many confirmations

                                                                              Parameter

                                                                              {Boolean} params.enforceMinConfirmsForChange - Enforces minConfirms on change inputs

                                                                              Parameter

                                                                              {Number} params.feeRate - fee rate to use in calculation of maximum spendable in satoshis/kB

                                                                              Parameter

                                                                              {Number} params.maxFeeRate - upper limit for feeRate in satoshis/kB

                                                                              Parameter

                                                                              {String} params.recipientAddress - recipient addresses for a more accurate calculation of the maximum available to send

                                                                              Parameter callback

                                                                              Returns

                                                                              {{maximumSpendable: Number, coin: String}} NOTE : feeTxConfirmTarget omitted on purpose because gauging the maximum spendable amount with dynamic fees does not make sense

                                                                            method migratedFrom

                                                                            migratedFrom: () => string | undefined;
                                                                            • Get the wallet id of the wallet that this wallet was migrated from.

                                                                              For example, if this is a BCH wallet that was created from a BTC wallet, the BCH wallet migrated from field would have the BTC wallet id.

                                                                            method pendingApprovals

                                                                            pendingApprovals: () => PendingApproval[];
                                                                            • Get all pending approvals on this wallet

                                                                            method prebuildAndSignTransaction

                                                                            prebuildAndSignTransaction: (
                                                                            params?: PrebuildAndSignTransactionOptions,
                                                                            callback?: NodeCallback<SignedTransaction>
                                                                            ) => Bluebird<SignedTransaction>;
                                                                            • Get a transaction prebuild from BitGo, validate it, and then decrypt the user key and sign the transaction

                                                                              Parameter params

                                                                              Parameter callback

                                                                            method prebuildConsolidateAccountParams

                                                                            prebuildConsolidateAccountParams: () => string[];
                                                                            • This is a strict sub-set of prebuildWhitelistedParams

                                                                            method prebuildTransaction

                                                                            prebuildTransaction: (
                                                                            params?: PrebuildTransactionOptions,
                                                                            callback?: NodeCallback<PrebuildTransactionResult>
                                                                            ) => Bluebird<PrebuildTransactionResult>;
                                                                            • Fetch a transaction prebuild (unsigned transaction) from BitGo

                                                                              Parameter params

                                                                              Parameter

                                                                              {{address: string, amount: string}} params.recipients - list of recipients and necessary recipient information

                                                                              Parameter

                                                                              {Number} params.numBlocks - Estimates the approximate fee per kilobyte necessary for a transaction confirmation within numBlocks blocks

                                                                              Parameter

                                                                              {Number} params.feeRate - the desired feeRate for the transaction in base units/kB

                                                                              Parameter

                                                                              {Number} params.maxFeeRate - upper limit for feeRate in base units/kB

                                                                              Parameter

                                                                              {Number} params.minConfirms - Minimum number of confirmations unspents going into this transaction should have

                                                                              Parameter

                                                                              {Boolean} params.enforceMinConfirmsForChange - Enforce minimum number of confirmations on change (internal) inputs.

                                                                              Parameter

                                                                              {Number} params.targetWalletUnspents - The desired count of unspents in the wallet. If the wallet’s current unspent count is lower than the target, up to four additional change outputs will be added to the transaction.

                                                                              Parameter

                                                                              {Number} params.minValue - Ignore unspents smaller than this amount of base units

                                                                              Parameter

                                                                              {Number} params.maxValue - Ignore unspents larger than this amount of base units

                                                                              Parameter

                                                                              {Number} params.sequenceId - The sequence ID of the transaction

                                                                              Parameter

                                                                              {Number} params.lastLedgerSequence - Absolute max ledger the transaction should be accepted in, whereafter it will be rejected.

                                                                              Parameter

                                                                              {Number} params.ledgerSequenceDelta - Relative ledger height (in relation to the current ledger) that the transaction should be accepted in, whereafter it will be rejected.

                                                                              Parameter

                                                                              {Number} params.gasPrice - Custom gas price to be used for sending the transaction

                                                                              Parameter

                                                                              {Number} params.gasLimit - Custom gas limit to be used for sending the transaction

                                                                              Parameter

                                                                              {Boolean} params.noSplitChange - Set to true to disable automatic change splitting for purposes of unspent management

                                                                              Parameter

                                                                              {Array} params.unspents - The unspents to use in the transaction. Each unspent should be in the form prevTxId:nOutput

                                                                              Parameter

                                                                              {String} params.changeAddress - Specifies the destination of the change output

                                                                              Parameter

                                                                              {Boolean} params.nonParticipation - (Algorand) Non participating key reg transaction

                                                                              Parameter

                                                                              {Number} params.validFromBlock - (Algorand) The minimum round this will run on

                                                                              Parameter

                                                                              {Number} params.validToBlock - (Algorand) The maximum round this will run on

                                                                              Parameter

                                                                              {Boolean} params.instant - Build this transaction to conform with instant sending coin-specific method (if available)

                                                                              Parameter

                                                                              {{value: String, type: String}} params.memo - Memo to use in transaction (supported by Stellar)

                                                                              Parameter

                                                                              {String} param.transferId - transfer Id to use in transaction (supported by casper)

                                                                              Parameter

                                                                              {String} params.addressType - The type of address to create for change. One of p2sh, p2shP2wsh, and p2wsh. Case-sensitive.

                                                                              Parameter

                                                                              {Boolean} params.hop - Build this as an Ethereum hop transaction

                                                                              Parameter

                                                                              {Object} params.reservation - Object to reserve the unspents that this tx build uses. Format is reservation = { expireTime: ISODateString, pendingApprovalId: String }

                                                                              Parameter

                                                                              {String} params.walletPassphrase The passphrase to the wallet user key, to sign commitment data for Ethereum hop transactions

                                                                              Parameter

                                                                              {String} params.walletContractAddress - The contract address used as the "to" field of a transaction

                                                                              Parameter callback

                                                                              Returns

                                                                              {*}

                                                                            method prebuildWhitelistedParams

                                                                            prebuildWhitelistedParams: () => string[];

                                                                              method receiveAddress

                                                                              receiveAddress: () => string;
                                                                              • Get a receive address for this wallet

                                                                              method recoverToken

                                                                              recoverToken: (
                                                                              params?: RecoverTokenOptions,
                                                                              callback?: NodeCallback<any>
                                                                              ) => Bluebird<any>;
                                                                              • Recover an unsupported token from a BitGo multisig wallet params are validated in Eth.prototype.recoverToken

                                                                                Parameter params

                                                                                Parameter

                                                                                params.tokenContractAddress the contract address of the unsupported token

                                                                                Parameter

                                                                                params.recipient the destination address recovered tokens should be sent to

                                                                                Parameter

                                                                                params.walletPassphrase the wallet passphrase

                                                                                Parameter

                                                                                params.prv the xprv

                                                                                Parameter callback

                                                                              method refresh

                                                                              refresh: (
                                                                              params?: Record<string, never>,
                                                                              callback?: NodeCallback<Wallet>
                                                                              ) => Bluebird<Wallet>;
                                                                              • Refresh the wallet object by syncing with the back-end

                                                                                Parameter params

                                                                                Parameter callback

                                                                                Returns

                                                                                {Wallet}

                                                                              method remove

                                                                              remove: (
                                                                              params?: Record<string, never>,
                                                                              callback?: NodeCallback<any>
                                                                              ) => Bluebird<any>;
                                                                              • Remove this wallet

                                                                                Parameter params

                                                                                Parameter callback

                                                                                Returns

                                                                                {*}

                                                                              method removePolicyRule

                                                                              removePolicyRule: (
                                                                              params?: RemovePolicyRuleOptions,
                                                                              callback?: NodeCallback<any>
                                                                              ) => Bluebird<any>;
                                                                              • Remove Policy Rule

                                                                                Parameter params

                                                                                Parameter callback

                                                                                Returns

                                                                                {*}

                                                                              method removeUser

                                                                              removeUser: (
                                                                              params?: RemoveUserOptions,
                                                                              callback?: NodeCallback<any>
                                                                              ) => Bluebird<any>;
                                                                              • Remove user from wallet

                                                                                Parameter params

                                                                                userId Id of the user to remove

                                                                                Parameter callback

                                                                                {*}

                                                                              method removeWebhook

                                                                              removeWebhook: (
                                                                              params?: ModifyWebhookOptions,
                                                                              callback?: NodeCallback<any>
                                                                              ) => Bluebird<any>;
                                                                              • Remove a webhook from this wallet

                                                                                Parameter params

                                                                                Parameter callback

                                                                              method send

                                                                              send: (params?: SendOptions, callback?: NodeCallback<any>) => Bluebird<any>;
                                                                              • Send coins to a recipient

                                                                                Parameter params

                                                                                Parameter

                                                                                params.address - the destination address

                                                                                Parameter

                                                                                params.amount - the amount in satoshis/wei/base value to be sent

                                                                                Parameter

                                                                                params.message - optional message to attach to transaction

                                                                                Parameter

                                                                                params.data - [Ethereum Specific] optional data to pass to transaction

                                                                                Parameter

                                                                                params.custodianTransactionId - [Ethereum/MMI Specific] id of transaction created via metamask

                                                                                Parameter

                                                                                params.walletPassphrase - the passphrase to be used to decrypt the user key on this wallet

                                                                                Parameter

                                                                                params.prv - the private key in string form, if walletPassphrase is not available

                                                                                Parameter

                                                                                params.minConfirms - the minimum confirmation threshold for inputs

                                                                                Parameter

                                                                                params.enforceMinConfirmsForChange - whether to enforce minConfirms for change inputs

                                                                                Parameter callback

                                                                                Returns

                                                                                {*}

                                                                              method sendAccountConsolidation

                                                                              sendAccountConsolidation: (
                                                                              params?: PrebuildAndSignTransactionOptions,
                                                                              callback?: NodeCallback<any>
                                                                              ) => Bluebird<any>;
                                                                              • Builds and sends a set of consolidation transactions for a wallet.

                                                                                Parameter params

                                                                                prebuildTx - this is the pre-build consolidation tx. this is a normally built tx with an additional parameter of consolidateId. verification - normal keychains, etc. for verification

                                                                              method sendAccountConsolidations

                                                                              sendAccountConsolidations: (
                                                                              params?: BuildConsolidationTransactionOptions,
                                                                              callback?: NodeCallback<any>
                                                                              ) => Bluebird<any>;
                                                                              • Builds and sends a set of account consolidations. This is intended to flush many balances to the root wallet balance.

                                                                                Parameter params

                                                                                consolidateAddresses - these are the on-chain receive addresses we want to pick a consolidation amount from

                                                                                Parameter callback

                                                                              method sendMany

                                                                              sendMany: (
                                                                              params?: SendManyOptions,
                                                                              callback?: NodeCallback<any>
                                                                              ) => Bluebird<any>;
                                                                              • Send money to multiple recipients 1. Gets the user keychain by checking the wallet for a key which has an encrypted prv 2. Decrypts user key 3. Creates the transaction with default fee 4. Signs transaction with decrypted user key 5. Sends the transaction to BitGo

                                                                                Parameter params

                                                                                Parameter

                                                                                {{address: string, amount: string}} params.recipients - list of recipients and necessary recipient information

                                                                                Parameter

                                                                                {Number} params.numBlocks - Estimates the approximate fee per kilobyte necessary for a transaction confirmation within numBlocks blocks

                                                                                Parameter

                                                                                {Number} params.feeRate - the desired feeRate for the transaction in satothis/kB

                                                                                Parameter

                                                                                {Number} params.maxFeeRate - upper limit for feeRate in satoshis/kB

                                                                                Parameter

                                                                                {Number} params.minConfirms - all selected unspents will have at least this many confirmations

                                                                                Parameter

                                                                                {Boolean} params.enforceMinConfirmsForChange - Enforces minConfirms on change inputs

                                                                                Parameter

                                                                                {Number} params.targetWalletUnspents - The desired count of unspents in the wallet

                                                                                Parameter

                                                                                {String} params.message - optional message to attach to transaction

                                                                                Parameter

                                                                                {Number} params.minValue - Ignore unspents smaller than this amount of satoshis

                                                                                Parameter

                                                                                {Number} params.maxValue - Ignore unspents larger than this amount of satoshis

                                                                                Parameter

                                                                                {Number} params.sequenceId - The sequence ID of the transaction

                                                                                Parameter

                                                                                {Number} params.lastLedgerSequence - Absolute max ledger the transaction should be accepted in, whereafter it will be rejected.

                                                                                Parameter

                                                                                {Number} params.ledgerSequenceDelta - Relative ledger height (in relation to the current ledger) that the transaction should be accepted in, whereafter it will be rejected.

                                                                                Parameter

                                                                                {Number} params.gasPrice - Custom gas price to be used for sending the transaction

                                                                                Parameter

                                                                                {Boolean} params.noSplitChange - Set to true to disable automatic change splitting for purposes of unspent management

                                                                                Parameter

                                                                                {Array} params.unspents - The unspents to use in the transaction. Each unspent should be in the form prevTxId:nOutput

                                                                                Parameter

                                                                                {String} params.comment - Any additional comment to attach to the transaction

                                                                                Parameter

                                                                                {String} params.otp - Two factor auth code to enable sending the transaction

                                                                                Parameter

                                                                                {String} params.changeAddress - Specifies the destination of the change output

                                                                                Parameter

                                                                                {Boolean} params.instant - Send this transaction using coin-specific instant sending method (if available)

                                                                                Parameter

                                                                                {{value: String, type: String}} params.memo - Memo to use in transaction (supported by Stellar)

                                                                                Parameter

                                                                                {String} params.type - Type of the transaction (e.g. trustline)

                                                                                Parameter

                                                                                {{token: params, action: String, limit: String}[]} options.trustlines - Array of trustlines to manage (supported by Stellar)

                                                                                Parameter callback

                                                                                Returns

                                                                                {*}

                                                                              method sendPaymentResponse

                                                                              sendPaymentResponse: (
                                                                              params?: any,
                                                                              callback?: NodeCallback<any>
                                                                              ) => Bluebird<any>;
                                                                              • Send json payment response

                                                                                Parameter params

                                                                                The params passed into the function

                                                                                Parameter

                                                                                {String} params.paymentUrl - The url to send the fully signed transaction to

                                                                                Parameter

                                                                                {String} params.txHex - The transaction hex of the payment

                                                                                Parameter

                                                                                {String} params.memo {String} - A memo supplied by the merchant, to be inserted into the transfer as the comment

                                                                                Parameter

                                                                                {String} params.expires {String} - ISO Date format of when the payment request expires

                                                                                Parameter callback

                                                                                Returns

                                                                                {Object} The info returned from the merchant server Payment Ack

                                                                                Deprecated

                                                                              method setPolicyRule

                                                                              setPolicyRule: (params?: any, callback?: NodeCallback<any>) => Bluebird<unknown>;
                                                                              • Update a policy rule

                                                                                Parameter params

                                                                                Parameter

                                                                                params.condition condition object

                                                                                Parameter

                                                                                params.action action object

                                                                                Parameter callback

                                                                                Returns

                                                                                {*}

                                                                              method shareWallet

                                                                              shareWallet: (
                                                                              params?: ShareWalletOptions,
                                                                              callback?: NodeCallback<any>
                                                                              ) => Bluebird<any>;
                                                                              • Share this wallet with another BitGo user.

                                                                                Parameter params

                                                                                Parameter callback

                                                                                Returns

                                                                                {*}

                                                                              method signTransaction

                                                                              signTransaction: (
                                                                              params?: WalletSignTransactionOptions,
                                                                              callback?: NodeCallback<SignedTransaction>
                                                                              ) => Bluebird<SignedTransaction>;
                                                                              • Sign a transaction

                                                                                Parameter params

                                                                                txPrebuild - [keychain / key] (object) or prv (string) - walletPassphrase

                                                                                Parameter callback

                                                                                {*}

                                                                              method simulateWebhook

                                                                              simulateWebhook: (
                                                                              params?: SimulateWebhookOptions,
                                                                              callback?: NodeCallback<any>
                                                                              ) => Bluebird<any>;
                                                                              • Simulate wallet webhook, currently for webhooks of type transfer and pending approval

                                                                                Parameter params

                                                                                webhookId (required) id of the webhook to be simulated - transferId (optional but required for transfer webhooks) id of the simulated transfer - pendingApprovalId (optional but required for pending approval webhooks) id of the simulated pending approval

                                                                                Parameter callback

                                                                                Returns

                                                                                {*}

                                                                              method spendableBalance

                                                                              spendableBalance: () => number;
                                                                              • Get the spendable balance of this wallet

                                                                              method spendableBalanceString

                                                                              spendableBalanceString: () => string;
                                                                              • Get a string representation of the spendable balance of this wallet

                                                                                This is useful when balances have the potential to overflow standard javascript numbers

                                                                              method submitTransaction

                                                                              submitTransaction: (
                                                                              params?: SubmitTransactionOptions,
                                                                              callback?: NodeCallback<any>
                                                                              ) => Bluebird<any>;
                                                                              • Submit a half-signed transaction to BitGo

                                                                                Parameter params

                                                                                txHex: transaction hex to submit - halfSigned: object containing transaction (txHex or txBase64) to submit

                                                                                Parameter callback

                                                                              method sweep

                                                                              sweep: (params?: SweepOptions, callback?: NodeCallback<any>) => Bluebird<any>;
                                                                              • Sweep funds for a wallet

                                                                                Parameter params

                                                                                parameters object

                                                                                Parameter

                                                                                {String} params.address - The address to send all the funds in the wallet to

                                                                                Parameter

                                                                                {String} params.walletPassphrase - the users wallet passphrase

                                                                                Parameter

                                                                                {String} params.xprv - the private key in string form if the walletPassphrase is not available

                                                                                Parameter

                                                                                {String} params.otp - Two factor auth code to enable sending the transaction

                                                                                Parameter

                                                                                {Number} params.feeTxConfirmTarget - Estimate the fees to aim for first confirmation within this number of blocks

                                                                                Parameter

                                                                                {Number} params.feeRate - The desired fee rate for the transaction in satoshis/kB

                                                                                Parameter

                                                                                {Number} [params.maxFeeRate] - upper limit for feeRate in satoshis/kB

                                                                                Parameter

                                                                                {Boolean} [params.allowPartialSweep] - allows sweeping 200 unspents when the wallet has more than that

                                                                                Parameter callback

                                                                                Returns

                                                                                txHex {String} the txHex of the signed transaction

                                                                              method toJSON

                                                                              toJSON: () => WalletData;
                                                                              • Extract a JSON representable version of this wallet

                                                                              method tokenFlushThresholds

                                                                              tokenFlushThresholds: () => any;
                                                                              • Return the token flush thresholds for this wallet {*|Object} pairs of { [tokenName]: thresholds } base units

                                                                              method toTradingAccount

                                                                              toTradingAccount: () => TradingAccount;
                                                                              • Create a trading account from this wallet

                                                                              method transactions

                                                                              transactions: (
                                                                              params?: PaginationOptions,
                                                                              callback?: NodeCallback<any>
                                                                              ) => Bluebird<any>;
                                                                              • List the transactions for a given wallet

                                                                                Parameter params

                                                                                Parameter callback

                                                                                Returns

                                                                                {*}

                                                                              method transferBySequenceId

                                                                              transferBySequenceId: (
                                                                              params?: TransferBySequenceIdOptions,
                                                                              callback?: NodeCallback<any>
                                                                              ) => Bluebird<any>;
                                                                              • Get a transaction by sequence id for a given wallet

                                                                                Parameter params

                                                                                Parameter callback

                                                                              method transferComment

                                                                              transferComment: (
                                                                              params?: TransferCommentOptions,
                                                                              callback?: NodeCallback<any>
                                                                              ) => Bluebird<any>;
                                                                              • Update comment of a transfer

                                                                                Parameter params

                                                                                Parameter callback

                                                                                Returns

                                                                                {*}

                                                                              method transfers

                                                                              transfers: (
                                                                              params?: TransfersOptions,
                                                                              callback?: NodeCallback<any>
                                                                              ) => Bluebird<any>;
                                                                              • List the transfers for a given wallet

                                                                                Parameter params

                                                                                Parameter callback

                                                                                Returns

                                                                                {*}

                                                                              method unspents

                                                                              unspents: (
                                                                              params?: UnspentsOptions,
                                                                              callback?: NodeCallback<any>
                                                                              ) => Bluebird<any>;
                                                                              • List the unspents for a given wallet

                                                                                Parameter params

                                                                                Parameter callback

                                                                                Returns

                                                                                {*}

                                                                              method updateAddress

                                                                              updateAddress: (
                                                                              params?: UpdateAddressOptions,
                                                                              callback?: NodeCallback<any>
                                                                              ) => Bluebird<any>;
                                                                              • Update properties on an address

                                                                                Parameter params

                                                                                Parameter callback

                                                                                Returns

                                                                                {*}

                                                                              method updateTokenFlushThresholds

                                                                              updateTokenFlushThresholds: (
                                                                              thresholds?: any,
                                                                              callback?: NodeCallback<any>
                                                                              ) => Bluebird<any>;
                                                                              • Set the token flush thresholds for the wallet. Updates the wallet. Tokens will only be flushed from forwarder contracts if the balance is greater than the threshold defined here.

                                                                                Parameter thresholds

                                                                                pairs of { [tokenName]: threshold } (base units)

                                                                                Parameter callback

                                                                              method url

                                                                              url: (extra?: string) => string;
                                                                              • Build a URL using this wallet's id which can be used for BitGo API operations

                                                                                Parameter extra

                                                                                API specific string to append to the wallet id

                                                                              class Wallets

                                                                              class Wallets {}

                                                                                constructor

                                                                                constructor(bitgo: BitGo, baseCoin: BaseCoin);

                                                                                  method acceptShare

                                                                                  acceptShare: (
                                                                                  params?: AcceptShareOptions,
                                                                                  callback?: NodeCallback<any>
                                                                                  ) => Bluebird<any>;
                                                                                  • Accepts a wallet share, adding the wallet to the user's list Needs a user's password to decrypt the shared key

                                                                                    Parameter params

                                                                                    Parameter

                                                                                    params.walletShareId - the wallet share to accept

                                                                                    Parameter

                                                                                    params.userPassword - (required if more a keychain was shared) user's password to decrypt the shared wallet

                                                                                    Parameter

                                                                                    params.newWalletPassphrase - new wallet passphrase for saving the shared wallet prv. If left blank and a wallet with more than view permissions was shared, then the user's login password is used.

                                                                                    Parameter

                                                                                    params.overrideEncryptedPrv - set only if the prv was received out-of-band.

                                                                                    Parameter callback

                                                                                  method add

                                                                                  add: (params?: AddWalletOptions, callback?: NodeCallback<any>) => Bluebird<any>;
                                                                                  • add Add a new wallet (advanced mode). This allows you to manually submit the keys, type, m and n of the wallet Parameters include: "label": label of the wallet to be shown in UI "m": number of keys required to unlock wallet (2) "n": number of keys available on the wallet (3) "keys": array of keychain ids

                                                                                  method cancelShare

                                                                                  cancelShare: (
                                                                                  params?: { walletShareId?: string },
                                                                                  callback?: NodeCallback<any>
                                                                                  ) => Bluebird<any>;
                                                                                  • Cancel a wallet share

                                                                                    Parameter params

                                                                                    Parameter

                                                                                    params.walletShareId - the wallet share to update

                                                                                    Parameter callback

                                                                                  method generateWallet

                                                                                  generateWallet: (
                                                                                  params?: GenerateWalletOptions,
                                                                                  callback?: NodeCallback<WalletWithKeychains>
                                                                                  ) => Bluebird<WalletWithKeychains>;
                                                                                  • Generate a new wallet 1. Creates the user keychain locally on the client, and encrypts it with the provided passphrase 2. If no pub was provided, creates the backup keychain locally on the client, and encrypts it with the provided passphrase 3. Uploads the encrypted user and backup keychains to BitGo 4. Creates the BitGo key on the service 5. Creates the wallet on BitGo with the 3 public keys above

                                                                                    Parameter params

                                                                                    Parameter

                                                                                    params.label

                                                                                    Parameter

                                                                                    params.passphrase

                                                                                    Parameter

                                                                                    params.userKey User xpub

                                                                                    Parameter

                                                                                    params.backupXpub Backup xpub

                                                                                    Parameter

                                                                                    params.backupXpubProvider

                                                                                    Parameter

                                                                                    params.enterprise

                                                                                    Parameter

                                                                                    params.disableTransactionNotifications

                                                                                    Parameter

                                                                                    params.passcodeEncryptionCode

                                                                                    Parameter

                                                                                    params.coldDerivationSeed

                                                                                    Parameter

                                                                                    params.gasPrice

                                                                                    Parameter

                                                                                    params.disableKRSEmail

                                                                                    Parameter

                                                                                    params.walletVersion

                                                                                    Parameter callback

                                                                                    Returns

                                                                                    {*}

                                                                                  method get

                                                                                  get: (
                                                                                  params?: GetWalletOptions,
                                                                                  callback?: NodeCallback<Wallet>
                                                                                  ) => Bluebird<Wallet>;
                                                                                  • Get a wallet by ID (proxy for getWallet)

                                                                                    Parameter params

                                                                                    Parameter callback

                                                                                  method getShare

                                                                                  getShare: (
                                                                                  params?: { walletShareId?: string },
                                                                                  callback?: NodeCallback<any>
                                                                                  ) => Bluebird<any>;
                                                                                  • Gets a wallet share information, including the encrypted sharing keychain. requires unlock if keychain is present.

                                                                                    Parameter params

                                                                                    Parameter

                                                                                    params.walletShareId - the wallet share to get information on

                                                                                    Parameter callback

                                                                                  method getTotalBalances

                                                                                  getTotalBalances: (
                                                                                  params?: Record<string, never>,
                                                                                  callback?: NodeCallback<any>
                                                                                  ) => Bluebird<any>;
                                                                                  • For any given supported coin, get total balances for all wallets of that coin type on the account.

                                                                                    Parameter params

                                                                                    Parameter callback

                                                                                    Returns

                                                                                    {*}

                                                                                  method getWallet

                                                                                  getWallet: (
                                                                                  params?: GetWalletOptions,
                                                                                  callback?: NodeCallback<Wallet>
                                                                                  ) => Bluebird<Wallet>;
                                                                                  • Get a wallet by its ID

                                                                                    Parameter params

                                                                                    Parameter

                                                                                    params.id wallet id

                                                                                    Parameter callback

                                                                                    Returns

                                                                                    {*}

                                                                                  method getWalletByAddress

                                                                                  getWalletByAddress: (
                                                                                  params?: GetWalletByAddressOptions,
                                                                                  callback?: NodeCallback<Wallet>
                                                                                  ) => Bluebird<Wallet>;
                                                                                  • Get a wallet by its address

                                                                                    Parameter params

                                                                                    Parameter

                                                                                    params.address wallet address

                                                                                    Parameter callback

                                                                                    Returns

                                                                                    {*}

                                                                                  method list

                                                                                  list: (
                                                                                  params?: ListWalletOptions,
                                                                                  callback?: NodeCallback<{ wallets: Wallet[] }>
                                                                                  ) => Bluebird<{ wallets: Wallet[] }>;
                                                                                  • List a user's wallets

                                                                                    Parameter params

                                                                                    Parameter callback

                                                                                    Returns

                                                                                    {*}

                                                                                  method listShares

                                                                                  listShares: (
                                                                                  params?: Record<string, unknown>,
                                                                                  callback?: NodeCallback<any>
                                                                                  ) => Bluebird<any>;
                                                                                  • List the user's wallet shares

                                                                                    Parameter params

                                                                                    Parameter callback

                                                                                  method resendShareInvite

                                                                                  resendShareInvite: (
                                                                                  params?: { walletShareId?: string },
                                                                                  callback?: NodeCallback<any>
                                                                                  ) => Bluebird<any>;
                                                                                  • Resend a wallet share invitation email

                                                                                    Parameter params

                                                                                    Parameter

                                                                                    params.walletShareId - the wallet share whose invitiation should be resent

                                                                                    Parameter callback

                                                                                  method updateShare

                                                                                  updateShare: (
                                                                                  params?: UpdateShareOptions,
                                                                                  callback?: NodeCallback<any>
                                                                                  ) => Bluebird<any>;
                                                                                  • Update a wallet share

                                                                                    Parameter

                                                                                    params.walletShareId - the wallet share to update

                                                                                    Parameter

                                                                                    params.state - the new state of the wallet share

                                                                                    Parameter params

                                                                                    Parameter callback

                                                                                  class Webhooks

                                                                                  class Webhooks {}

                                                                                    constructor

                                                                                    constructor(bitgo: BitGo, baseCoin: BaseCoin);

                                                                                      method add

                                                                                      add: (params: AddOptions, callback: NodeCallback<any>) => Bluebird<any>;
                                                                                      • Add new user webhook

                                                                                        Parameter params

                                                                                        Parameter callback

                                                                                        Returns

                                                                                        {*}

                                                                                      method list

                                                                                      list: (callback: NodeCallback<any>) => Bluebird<any>;
                                                                                      • Fetch list of user webhooks

                                                                                        Parameter callback

                                                                                        Returns

                                                                                        {*}

                                                                                      method listNotifications

                                                                                      listNotifications: (
                                                                                      params: ListNotificationsOptions | undefined,
                                                                                      callback: NodeCallback<any>
                                                                                      ) => Bluebird<any>;
                                                                                      • Fetch list of webhook notifications for the user

                                                                                        Parameter params

                                                                                        Parameter callback

                                                                                        Returns

                                                                                        {*}

                                                                                      method remove

                                                                                      remove: (params: RemoveOptions, callback: NodeCallback<any>) => Bluebird<any>;
                                                                                      • Remove user webhook

                                                                                        Parameter params

                                                                                        Parameter callback

                                                                                        Returns

                                                                                        {*}

                                                                                      method simulate

                                                                                      simulate: (
                                                                                      params: SimulateOptions,
                                                                                      callback: NodeCallback<any>
                                                                                      ) => Bluebird<any>;
                                                                                      • Simulate a user webhook

                                                                                        Parameter params

                                                                                        Parameter callback

                                                                                        Returns

                                                                                        {*}

                                                                                      Interfaces

                                                                                      interface AccelerateTransactionOptions

                                                                                      interface AccelerateTransactionOptions {}

                                                                                        property cpfpFeeRate

                                                                                        cpfpFeeRate?: number;

                                                                                          property cpfpTxIds

                                                                                          cpfpTxIds?: string[];

                                                                                            property maxFee

                                                                                            maxFee?: number;

                                                                                              property noCpfpFeeRate

                                                                                              noCpfpFeeRate?: boolean;

                                                                                                property noMaxFee

                                                                                                noMaxFee?: boolean;

                                                                                                  property recipients

                                                                                                  recipients?: {
                                                                                                  address: string;
                                                                                                  amount: string;
                                                                                                  }[];

                                                                                                    index signature

                                                                                                    [index: string]: unknown;

                                                                                                      interface AcceptShareOptions

                                                                                                      interface AcceptShareOptions {}

                                                                                                        property newWalletPassphrase

                                                                                                        newWalletPassphrase?: string;

                                                                                                          property overrideEncryptedPrv

                                                                                                          overrideEncryptedPrv?: string;

                                                                                                            property userPassword

                                                                                                            userPassword?: string;

                                                                                                              property walletShareId

                                                                                                              walletShareId?: string;

                                                                                                                interface AccessTokenOptions

                                                                                                                interface AccessTokenOptions {}

                                                                                                                  property accessToken

                                                                                                                  accessToken: string;

                                                                                                                    interface AddAccessTokenOptions

                                                                                                                    interface AddAccessTokenOptions {}

                                                                                                                      property duration

                                                                                                                      duration?: number;

                                                                                                                        property ipRestrict

                                                                                                                        ipRestrict?: string[];

                                                                                                                          property label

                                                                                                                          label: string;

                                                                                                                            property otp

                                                                                                                            otp?: string;

                                                                                                                              property scope

                                                                                                                              scope: string[];

                                                                                                                                property txValueLimit

                                                                                                                                txValueLimit?: number;

                                                                                                                                  interface AddOptions

                                                                                                                                  interface AddOptions {}

                                                                                                                                    property type

                                                                                                                                    type: string;

                                                                                                                                      property url

                                                                                                                                      url: string;

                                                                                                                                        interface AddressCoinSpecific

                                                                                                                                        interface AddressCoinSpecific {}

                                                                                                                                          property baseAddress

                                                                                                                                          baseAddress?: string;

                                                                                                                                            property forwarderVersion

                                                                                                                                            forwarderVersion?: number;

                                                                                                                                              property outputScript

                                                                                                                                              outputScript?: string;

                                                                                                                                                property pendingChainInitialization

                                                                                                                                                pendingChainInitialization?: boolean;

                                                                                                                                                  property redeemScript

                                                                                                                                                  redeemScript?: string;

                                                                                                                                                    property witnessScript

                                                                                                                                                    witnessScript?: string;

                                                                                                                                                      interface AddressesOptions

                                                                                                                                                      interface AddressesOptions extends PaginationOptions {}

                                                                                                                                                        property chains

                                                                                                                                                        chains?: number[];

                                                                                                                                                          property labelContains

                                                                                                                                                          labelContains?: string;

                                                                                                                                                            property mine

                                                                                                                                                            mine?: boolean;

                                                                                                                                                              property segwit

                                                                                                                                                              segwit?: boolean;

                                                                                                                                                                property sort

                                                                                                                                                                sort?: number;

                                                                                                                                                                  interface AddressVerificationData

                                                                                                                                                                  interface AddressVerificationData {}

                                                                                                                                                                    property chain

                                                                                                                                                                    chain?: number;

                                                                                                                                                                      property coinSpecific

                                                                                                                                                                      coinSpecific?: AddressCoinSpecific;

                                                                                                                                                                        property index

                                                                                                                                                                        index?: number;

                                                                                                                                                                          interface AddWalletOptions

                                                                                                                                                                          interface AddWalletOptions {}

                                                                                                                                                                            property address

                                                                                                                                                                            address?: string;

                                                                                                                                                                              property clientFlags

                                                                                                                                                                              clientFlags?: string[];

                                                                                                                                                                                property disableTransactionNotifications

                                                                                                                                                                                disableTransactionNotifications?: boolean;

                                                                                                                                                                                  property gasPrice

                                                                                                                                                                                  gasPrice?: number;

                                                                                                                                                                                    property initializationTxs

                                                                                                                                                                                    initializationTxs?: any;

                                                                                                                                                                                      property isCold

                                                                                                                                                                                      isCold?: boolean;

                                                                                                                                                                                        property isCustodial

                                                                                                                                                                                        isCustodial?: boolean;

                                                                                                                                                                                          property keys

                                                                                                                                                                                          keys?: string[];

                                                                                                                                                                                            property m

                                                                                                                                                                                            m?: number;

                                                                                                                                                                                              property n

                                                                                                                                                                                              n?: number;

                                                                                                                                                                                                property rootPrivateKey

                                                                                                                                                                                                rootPrivateKey?: string;

                                                                                                                                                                                                  property rootPub

                                                                                                                                                                                                  rootPub?: string;

                                                                                                                                                                                                    property signingKeyId

                                                                                                                                                                                                    signingKeyId?: string;

                                                                                                                                                                                                      property tags

                                                                                                                                                                                                      tags?: string[];

                                                                                                                                                                                                        property type

                                                                                                                                                                                                        type?: string;

                                                                                                                                                                                                          property walletVersion

                                                                                                                                                                                                          walletVersion?: number;

                                                                                                                                                                                                            interface ApproveOptions

                                                                                                                                                                                                            interface ApproveOptions {}

                                                                                                                                                                                                              property otp

                                                                                                                                                                                                              otp?: string;

                                                                                                                                                                                                                property tx

                                                                                                                                                                                                                tx?: string;

                                                                                                                                                                                                                  property walletPassphrase

                                                                                                                                                                                                                  walletPassphrase?: string;

                                                                                                                                                                                                                    property xprv

                                                                                                                                                                                                                    xprv?: string;

                                                                                                                                                                                                                      interface AuthenticateOptions

                                                                                                                                                                                                                      interface AuthenticateOptions {}

                                                                                                                                                                                                                        property extensible

                                                                                                                                                                                                                        extensible?: boolean;

                                                                                                                                                                                                                          property forceSMS

                                                                                                                                                                                                                          forceSMS?: boolean;

                                                                                                                                                                                                                            property forceV1Auth

                                                                                                                                                                                                                            forceV1Auth?: boolean;

                                                                                                                                                                                                                              property otp

                                                                                                                                                                                                                              otp?: string;

                                                                                                                                                                                                                                property password

                                                                                                                                                                                                                                password: string;

                                                                                                                                                                                                                                  property trust

                                                                                                                                                                                                                                  trust?: number;

                                                                                                                                                                                                                                    property username

                                                                                                                                                                                                                                    username: string;

                                                                                                                                                                                                                                      interface AuthenticateWithAuthCodeOptions

                                                                                                                                                                                                                                      interface AuthenticateWithAuthCodeOptions {}

                                                                                                                                                                                                                                        property authCode

                                                                                                                                                                                                                                        authCode: string;

                                                                                                                                                                                                                                          interface BitGo

                                                                                                                                                                                                                                          interface BitGo {}

                                                                                                                                                                                                                                            method del

                                                                                                                                                                                                                                            del: (url: string) => BitGoRequest;

                                                                                                                                                                                                                                              method get

                                                                                                                                                                                                                                              get: (url: string) => BitGoRequest;

                                                                                                                                                                                                                                                method patch

                                                                                                                                                                                                                                                patch: (url: string) => BitGoRequest;

                                                                                                                                                                                                                                                  method post

                                                                                                                                                                                                                                                  post: (url: string) => BitGoRequest;

                                                                                                                                                                                                                                                    method put

                                                                                                                                                                                                                                                    put: (url: string) => BitGoRequest;

                                                                                                                                                                                                                                                      interface BitGoJson

                                                                                                                                                                                                                                                      interface BitGoJson {}

                                                                                                                                                                                                                                                        property ecdhXprv

                                                                                                                                                                                                                                                        ecdhXprv?: string;

                                                                                                                                                                                                                                                          property extensionKey

                                                                                                                                                                                                                                                          extensionKey?: string;

                                                                                                                                                                                                                                                            property token

                                                                                                                                                                                                                                                            token?: string;

                                                                                                                                                                                                                                                              property user

                                                                                                                                                                                                                                                              user?: User;

                                                                                                                                                                                                                                                                interface BitGoOptions

                                                                                                                                                                                                                                                                interface BitGoOptions {}

                                                                                                                                                                                                                                                                  property accessToken

                                                                                                                                                                                                                                                                  accessToken?: string;

                                                                                                                                                                                                                                                                    property authVersion

                                                                                                                                                                                                                                                                    authVersion?: 2 | 3;

                                                                                                                                                                                                                                                                      property clientId

                                                                                                                                                                                                                                                                      clientId?: string;

                                                                                                                                                                                                                                                                        property clientSecret

                                                                                                                                                                                                                                                                        clientSecret?: string;

                                                                                                                                                                                                                                                                          property customBitcoinNetwork

                                                                                                                                                                                                                                                                          customBitcoinNetwork?: V1Network;

                                                                                                                                                                                                                                                                            property customRootURI

                                                                                                                                                                                                                                                                            customRootURI?: string;

                                                                                                                                                                                                                                                                              property customSigningAddress

                                                                                                                                                                                                                                                                              customSigningAddress?: string;

                                                                                                                                                                                                                                                                                property env

                                                                                                                                                                                                                                                                                env?: EnvironmentName;

                                                                                                                                                                                                                                                                                  property etherscanApiToken

                                                                                                                                                                                                                                                                                  etherscanApiToken?: string;

                                                                                                                                                                                                                                                                                    property hmacVerification

                                                                                                                                                                                                                                                                                    hmacVerification?: boolean;

                                                                                                                                                                                                                                                                                      property proxy

                                                                                                                                                                                                                                                                                      proxy?: string;

                                                                                                                                                                                                                                                                                        property refreshToken

                                                                                                                                                                                                                                                                                        refreshToken?: string;

                                                                                                                                                                                                                                                                                          property serverXpub

                                                                                                                                                                                                                                                                                          serverXpub?: string;

                                                                                                                                                                                                                                                                                            property stellarFederationServerUrl

                                                                                                                                                                                                                                                                                            stellarFederationServerUrl?: string;

                                                                                                                                                                                                                                                                                              property useProduction

                                                                                                                                                                                                                                                                                              useProduction?: boolean;

                                                                                                                                                                                                                                                                                                property userAgent

                                                                                                                                                                                                                                                                                                userAgent?: string;

                                                                                                                                                                                                                                                                                                  property validate

                                                                                                                                                                                                                                                                                                  validate?: boolean;

                                                                                                                                                                                                                                                                                                    interface BitGoSimulateWebhookOptions

                                                                                                                                                                                                                                                                                                    interface BitGoSimulateWebhookOptions {}

                                                                                                                                                                                                                                                                                                      property blockId

                                                                                                                                                                                                                                                                                                      blockId: string;

                                                                                                                                                                                                                                                                                                        property webhookId

                                                                                                                                                                                                                                                                                                        webhookId: string;

                                                                                                                                                                                                                                                                                                          interface BuildConsolidationTransactionOptions

                                                                                                                                                                                                                                                                                                          interface BuildConsolidationTransactionOptions extends PrebuildTransactionOptions {}
                                                                                                                                                                                                                                                                                                          • A small set of parameters should be used for building a consolidation transaction: - walletPassphrase - necessary for signing - feeRate - maxFeeRate - validFromBlock - validToBlock

                                                                                                                                                                                                                                                                                                            What shouldn't be passed (these will be ignored): - recipients

                                                                                                                                                                                                                                                                                                          property consolidateAddresses

                                                                                                                                                                                                                                                                                                          consolidateAddresses?: string[];

                                                                                                                                                                                                                                                                                                            interface CalculateHmacSubjectOptions

                                                                                                                                                                                                                                                                                                            interface CalculateHmacSubjectOptions {}

                                                                                                                                                                                                                                                                                                              property method

                                                                                                                                                                                                                                                                                                              method: typeof supportedRequestMethods[number];

                                                                                                                                                                                                                                                                                                                property statusCode

                                                                                                                                                                                                                                                                                                                statusCode?: number;

                                                                                                                                                                                                                                                                                                                  property text

                                                                                                                                                                                                                                                                                                                  text: string;

                                                                                                                                                                                                                                                                                                                    property timestamp

                                                                                                                                                                                                                                                                                                                    timestamp: number;

                                                                                                                                                                                                                                                                                                                      property urlPath

                                                                                                                                                                                                                                                                                                                      urlPath: string;

                                                                                                                                                                                                                                                                                                                        interface CalculateRequestHeadersOptions

                                                                                                                                                                                                                                                                                                                        interface CalculateRequestHeadersOptions {}

                                                                                                                                                                                                                                                                                                                          property method

                                                                                                                                                                                                                                                                                                                          method: typeof supportedRequestMethods[number];

                                                                                                                                                                                                                                                                                                                            property text

                                                                                                                                                                                                                                                                                                                            text: string;

                                                                                                                                                                                                                                                                                                                              property token

                                                                                                                                                                                                                                                                                                                              token: string;

                                                                                                                                                                                                                                                                                                                                property url

                                                                                                                                                                                                                                                                                                                                url: string;

                                                                                                                                                                                                                                                                                                                                  interface CalculateRequestHmacOptions

                                                                                                                                                                                                                                                                                                                                  interface CalculateRequestHmacOptions {}

                                                                                                                                                                                                                                                                                                                                    property method

                                                                                                                                                                                                                                                                                                                                    method: typeof supportedRequestMethods[number];

                                                                                                                                                                                                                                                                                                                                      property text

                                                                                                                                                                                                                                                                                                                                      text: string;

                                                                                                                                                                                                                                                                                                                                        property timestamp

                                                                                                                                                                                                                                                                                                                                        timestamp: number;

                                                                                                                                                                                                                                                                                                                                          property token

                                                                                                                                                                                                                                                                                                                                          token: string;

                                                                                                                                                                                                                                                                                                                                            property url

                                                                                                                                                                                                                                                                                                                                            url: string;

                                                                                                                                                                                                                                                                                                                                              interface ChangedKeychains

                                                                                                                                                                                                                                                                                                                                              interface ChangedKeychains {}

                                                                                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                                                                                [pubkey: string]: string;

                                                                                                                                                                                                                                                                                                                                                  interface ChangeFeeOptions

                                                                                                                                                                                                                                                                                                                                                  interface ChangeFeeOptions {}

                                                                                                                                                                                                                                                                                                                                                    property fee

                                                                                                                                                                                                                                                                                                                                                    fee?: string;

                                                                                                                                                                                                                                                                                                                                                      property txid

                                                                                                                                                                                                                                                                                                                                                      txid?: string;

                                                                                                                                                                                                                                                                                                                                                        interface ChangePasswordOptions

                                                                                                                                                                                                                                                                                                                                                        interface ChangePasswordOptions {}

                                                                                                                                                                                                                                                                                                                                                          property newPassword

                                                                                                                                                                                                                                                                                                                                                          newPassword: string;

                                                                                                                                                                                                                                                                                                                                                            property oldPassword

                                                                                                                                                                                                                                                                                                                                                            oldPassword: string;

                                                                                                                                                                                                                                                                                                                                                              interface ConsolidateUnspentsOptions

                                                                                                                                                                                                                                                                                                                                                              interface ConsolidateUnspentsOptions {}

                                                                                                                                                                                                                                                                                                                                                                property comment

                                                                                                                                                                                                                                                                                                                                                                comment?: string;

                                                                                                                                                                                                                                                                                                                                                                  property enforceMinConfirmsForChange

                                                                                                                                                                                                                                                                                                                                                                  enforceMinConfirmsForChange?: boolean;

                                                                                                                                                                                                                                                                                                                                                                    property feeRate

                                                                                                                                                                                                                                                                                                                                                                    feeRate?: number;

                                                                                                                                                                                                                                                                                                                                                                      property feeTxConfirmTarget

                                                                                                                                                                                                                                                                                                                                                                      feeTxConfirmTarget?: number;

                                                                                                                                                                                                                                                                                                                                                                        property limit

                                                                                                                                                                                                                                                                                                                                                                        limit?: number;

                                                                                                                                                                                                                                                                                                                                                                          property maxFeePercentage

                                                                                                                                                                                                                                                                                                                                                                          maxFeePercentage?: number;

                                                                                                                                                                                                                                                                                                                                                                            property maxFeeRate

                                                                                                                                                                                                                                                                                                                                                                            maxFeeRate?: number;

                                                                                                                                                                                                                                                                                                                                                                              property maxValue

                                                                                                                                                                                                                                                                                                                                                                              maxValue?: number;

                                                                                                                                                                                                                                                                                                                                                                                property minConfirms

                                                                                                                                                                                                                                                                                                                                                                                minConfirms?: number;

                                                                                                                                                                                                                                                                                                                                                                                  property minHeight

                                                                                                                                                                                                                                                                                                                                                                                  minHeight?: number;

                                                                                                                                                                                                                                                                                                                                                                                    property minValue

                                                                                                                                                                                                                                                                                                                                                                                    minValue?: number;

                                                                                                                                                                                                                                                                                                                                                                                      property numUnspentsToMake

                                                                                                                                                                                                                                                                                                                                                                                      numUnspentsToMake?: number;

                                                                                                                                                                                                                                                                                                                                                                                        property otp

                                                                                                                                                                                                                                                                                                                                                                                        otp?: string;

                                                                                                                                                                                                                                                                                                                                                                                          property targetAddress

                                                                                                                                                                                                                                                                                                                                                                                          targetAddress?: string;

                                                                                                                                                                                                                                                                                                                                                                                            property walletPassphrase

                                                                                                                                                                                                                                                                                                                                                                                            walletPassphrase?: string;

                                                                                                                                                                                                                                                                                                                                                                                              property xprv

                                                                                                                                                                                                                                                                                                                                                                                              xprv?: string;

                                                                                                                                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                                                                                                                                [index: string]: unknown;

                                                                                                                                                                                                                                                                                                                                                                                                  interface CreateAddressOptions

                                                                                                                                                                                                                                                                                                                                                                                                  interface CreateAddressOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                    property chain

                                                                                                                                                                                                                                                                                                                                                                                                    chain?: number;

                                                                                                                                                                                                                                                                                                                                                                                                      property count

                                                                                                                                                                                                                                                                                                                                                                                                      count?: number;

                                                                                                                                                                                                                                                                                                                                                                                                        property format

                                                                                                                                                                                                                                                                                                                                                                                                        format?: 'base58' | 'cashaddr';

                                                                                                                                                                                                                                                                                                                                                                                                          property forwarderVersion

                                                                                                                                                                                                                                                                                                                                                                                                          forwarderVersion?: number;

                                                                                                                                                                                                                                                                                                                                                                                                            property gasPrice

                                                                                                                                                                                                                                                                                                                                                                                                            gasPrice?: number | string;

                                                                                                                                                                                                                                                                                                                                                                                                              property label

                                                                                                                                                                                                                                                                                                                                                                                                              label?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                property lowPriority

                                                                                                                                                                                                                                                                                                                                                                                                                lowPriority?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                  interface CreateBackupOptions

                                                                                                                                                                                                                                                                                                                                                                                                                  interface CreateBackupOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                    property disableKRSEmail

                                                                                                                                                                                                                                                                                                                                                                                                                    disableKRSEmail?: