bitgo

  • Version 11.18.0
  • Published
  • 28.5 MB
  • 37 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 bitcoin

const bitcoin: any;

    variable bs58

    const bs58: any;

      variable Environments

      const Environments: common.Environments;

        variable Errors

        const Errors: typeof errors;

          variable GlobalCoinFactory

          const GlobalCoinFactory: CoinFactory;

            variable sjcl

            const sjcl: any;

              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, rmg, xrp, xlm)

                        method bigUnitsToBaseUnits

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

                          Parameter bigUnits

                        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>) => 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?: any) => 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>>
                          ) => any;
                          • 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) => any;

                            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>
                                ) => any;

                                  method pendingApprovals

                                  pendingApprovals: () => PendingApprovals;

                                    method postProcessPrebuild

                                    postProcessPrebuild: (
                                    prebuildResponse: TransactionPrebuild,
                                    callback?: NodeCallback<TransactionPrebuild>
                                    ) => any;
                                    • 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>
                                    ) => any;
                                    • Coin-specific things done before signing a transaction, i.e. verification

                                    method signMessage

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

                                      Parameter key

                                      Parameter message

                                      Parameter callback

                                    method signTransaction

                                    abstract signTransaction: (params: SignTransactionOptions) => any;
                                    • Sign a transaction

                                    method supplementGenerateWallet

                                    supplementGenerateWallet: (
                                    walletParams: SupplementGenerateWalletOptions,
                                    keychains: KeychainsTriplet
                                    ) => 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) => any;

                                        method verifyTransaction

                                        abstract verifyTransaction: (
                                        params: VerifyTransactionOptions,
                                        callback?: NodeCallback<boolean>
                                        ) => any;
                                        • 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,
                                              callback?: NodeCallback<any>
                                              ) => any;
                                              • addAccessToken Add a BitGo API Access Token to the current user account

                                                Parameter params

                                                Parameter callback

                                                { 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, callback?: NodeCallback<any>) => any;
                                              • Add new user webhook

                                                Parameter params

                                                Parameter callback

                                                Returns

                                                {*}

                                                Deprecated

                                              method authenticate

                                              authenticate: (params: AuthenticateOptions, callback?: NodeCallback<any>) => any;
                                              • Login to the bitgo platform.

                                              method authenticateWithAccessToken

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

                                              method authenticateWithAuthCode

                                              authenticateWithAuthCode: (
                                              params: AuthenticateWithAuthCodeOptions,
                                              callback?: NodeCallback<any>
                                              ) => 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, callback?: NodeCallback<any>) => 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

                                                Parameter callback

                                                {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,
                                              callback?: NodeCallback<any>
                                              ) => 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

                                                Parameter callback

                                              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, callback?: NodeCallback<any>) => 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, callback?: NodeCallback<any>) => 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

                                                Parameter callback

                                              method fetchConstants

                                              fetchConstants: (
                                              params?: Record<string, never>,
                                              callback?: NodeCallback<any>
                                              ) => any;
                                              • Receives a TTL and refetches as necessary

                                                Parameter params

                                                Parameter callback

                                              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: (
                                              params?: Record<string, never>,
                                              callback?: NodeCallback<any>
                                              ) => any;
                                              • Get a target address for payment of a BitGo fee

                                                Parameter params

                                                Parameter callback

                                                Deprecated

                                              method getConstants

                                              getConstants: (params?: Record<string, never>) => 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.

                                                Parameter params

                                                {Object} The client constants object

                                                Deprecated

                                              method getECDHSecret

                                              getECDHSecret: ({ otherPubKeyHex, eckey }: GetEcdhSecretOptions) => string;
                                              • Construct an ECDH secret from a private key and other user's public key

                                              method getECDHSharingKeychain

                                              getECDHSharingKeychain: (
                                              params?: Record<string, never>,
                                              callback?: NodeCallback<any>
                                              ) => 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,
                                              callback?: NodeCallback<any>
                                              ) => any;
                                              • Get a key for sharing a wallet with a user

                                                Parameter email

                                                email of user to share wallet with

                                                Parameter callback

                                              method getUser

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

                                                Parameter id

                                                Parameter callback

                                              method getValidate

                                              getValidate: () => boolean;

                                              method getWalletAddress

                                              getWalletAddress: (
                                              { address }: { address: string },
                                              callback?: NodeCallback<any>
                                              ) => 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 }, callback?: NodeCallback<any>) => any;
                                              • Get BitGo's guarantee using an instant id

                                                Parameter params

                                                Parameter callback

                                                Deprecated

                                              method keychains

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

                                                Deprecated

                                              method labels

                                              labels: (params?: Record<string, never>, callback?: NodeCallback<any>) => any;
                                              • Get all the address labels on all of the user's wallets

                                              method listAccessTokens

                                              listAccessTokens: (
                                              params?: Record<string, never>,
                                              callback?: NodeCallback<any>
                                              ) => 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,
                                              callback?: NodeCallback<any>
                                              ) => any;
                                              • Fetch list of webhook notifications for the user

                                                Parameter params

                                                Parameter callback

                                                Returns

                                                {*}

                                              method listWebhooks

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

                                                Parameter callback

                                                Returns

                                                {*}

                                                Deprecated

                                              method lock

                                              lock: (params?: Record<string, never>, callback?: NodeCallback<any>) => any;
                                              • Lock the session

                                                Parameter params

                                                Parameter callback

                                              method logout

                                              logout: (params?: Record<string, never>, callback?: NodeCallback<any>) => any;
                                              • Logout of BitGo

                                                Parameter params

                                                Parameter callback

                                              method market

                                              market: (params?: Record<string, never>, callback?: NodeCallback<any>) => 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

                                              method me

                                              me: (params?: Record<string, never>, callback?: NodeCallback<any>) => any;
                                              • Get the current logged in user

                                                Parameter params

                                                Parameter callback

                                              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, callback?: NodeCallback<any>) => any;
                                              • Test connectivity to the server

                                                Parameter params

                                                Parameter callback

                                              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 },
                                              callback?: NodeCallback<any>
                                              ) => 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: any, callback?: NodeCallback<any>) => any;
                                              • Parameter params

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

                                                Parameter callback

                                                Returns

                                                {*}

                                                Deprecated

                                              method reject

                                              reject: (msg: string, callback?: NodeCallback<never>) => any;
                                              • Helper function to return a rejected promise or call callback with error

                                                Deprecated

                                              method removeAccessToken

                                              removeAccessToken: (
                                              { id, label }: RemoveAccessTokenOptions,
                                              callback?: NodeCallback<any>
                                              ) => 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

                                                Parameter callback

                                              method removeWebhook

                                              removeWebhook: (params: WebhookOptions, callback: any) => any;
                                              • Remove user webhook

                                                Parameter params

                                                Parameter callback

                                                Returns

                                                {*}

                                                Deprecated

                                              method sendOTP

                                              sendOTP: (params?: { forceSMS?: boolean }, callback?: NodeCallback<any>) => 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: (params?: Record<string, never>, callback?: NodeCallback<any>) => 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,
                                              callback?: NodeCallback<any>
                                              ) => any;
                                              • Simulate a user webhook

                                                Parameter params

                                                Parameter callback

                                                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>) => any;
                                              • 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, callback?: NodeCallback<any>) => 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).

                                                Parameter callback

                                              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,
                                              callback?: NodeCallback<any>
                                              ) => any;

                                              method verifyPushToken

                                              verifyPushToken: (
                                              params: VerifyPushTokenOptions,
                                              callback?: NodeCallback<any>
                                              ) => any;
                                              • Parameter params

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

                                                Parameter callback

                                                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: (params?: Record<string, never>, callback?: NodeCallback<any>) => any;
                                              • Get market data from yesterday (Deprecated: Will be removed in the future) use bitgo.markets().yesterday()

                                              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>) => 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[]>
                                                          ) => any;
                                                          • Get the wallets associated with this Enterprise

                                                            Parameter params

                                                            Parameter callback

                                                          method getFeeAddressBalance

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

                                                            Parameter params

                                                            Parameter callback

                                                          method getFirstPendingTransaction

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

                                                            Parameter params

                                                            Parameter callback

                                                          method removeUser

                                                          removeUser: (params?: any, callback?: NodeCallback<any>) => 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>) => 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>) => any;
                                                              • Create a new enterprise

                                                                Parameter params

                                                                Parameter callback

                                                              method get

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

                                                                Parameter params

                                                                Parameter callback

                                                              method list

                                                              list: (
                                                              params?: Record<string, never>,
                                                              callback?: NodeCallback<Enterprise[]>
                                                              ) => any;
                                                              • 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>) => any;
                                                                  • 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>
                                                                  ) => any;
                                                                  • Create a backup key

                                                                    Parameter params

                                                                    Parameter

                                                                    params.provider (optional)

                                                                    Parameter callback

                                                                  method createBitGo

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

                                                                    Parameter params

                                                                    (empty)

                                                                    Parameter callback

                                                                  method get

                                                                  get: (params: GetKeychainOptions, callback?: NodeCallback<Keychain>) => any;
                                                                  • 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[]>
                                                                  ) => any;
                                                                  • Gets keys for signing from a wallet

                                                                    Parameter params

                                                                    Parameter callback

                                                                    Returns

                                                                    {Bluebird[]}

                                                                  method list

                                                                  list: (
                                                                  params?: ListKeychainOptions,
                                                                  callback?: NodeCallback<ListKeychainsResult>
                                                                  ) => any;
                                                                  • 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>
                                                                  ) => any;
                                                                  • 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>) => 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>) => 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>) => 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>) => any;
                                                                          • Sets this PendingApproval to an approved state

                                                                          method cancel

                                                                          cancel: (params?: {}, callback?: NodeCallback<any>) => 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>
                                                                          ) => any;
                                                                          • 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>) => 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>) => 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>
                                                                              ) => any;
                                                                              • Fetch an existing pending approval

                                                                                Parameter params

                                                                                Parameter callback

                                                                              method list

                                                                              list: (
                                                                              params?: ListPendingApprovalsOptions,
                                                                              callback?: NodeCallback<ListPendingApprovalsResult>
                                                                              ) => any;
                                                                              • 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>
                                                                                      ) => any;
                                                                                      • Accelerate a transaction's confirmation using Child-Pays-For-Parent (CPFP)

                                                                                        Parameter params

                                                                                        Parameter callback

                                                                                      method addresses

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

                                                                                        Parameter params

                                                                                        Parameter callback

                                                                                        Returns

                                                                                        {*}

                                                                                      method addWebhook

                                                                                      addWebhook: (params?: ModifyWebhookOptions, callback?: NodeCallback<any>) => 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[]>
                                                                                      ) => any;
                                                                                      • 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>) => 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>
                                                                                      ) => 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>
                                                                                      ) => 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>
                                                                                      ) => 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>) => 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>
                                                                                      ) => 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>) => any;
                                                                                      • Freeze a given wallet

                                                                                        Parameter params

                                                                                        Parameter callback

                                                                                        Returns

                                                                                        {*}

                                                                                      method getAddress

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

                                                                                        Parameter params

                                                                                        Parameter callback

                                                                                        Returns

                                                                                        {*}

                                                                                      method getEncryptedUserKeychain

                                                                                      getEncryptedUserKeychain: (
                                                                                      params?: Record<string, never>,
                                                                                      callback?: NodeCallback<any>
                                                                                      ) => 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>
                                                                                      ) => 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>) => 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>) => 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>
                                                                                      ) => 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>) => 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>) => any;
                                                                                      • List webhooks on this wallet

                                                                                        Parameter params

                                                                                        Parameter callback

                                                                                      method maximumSpendable

                                                                                      maximumSpendable: (
                                                                                      params?: MaximumSpendableOptions,
                                                                                      callback?: NodeCallback<MaximumSpendable>
                                                                                      ) => any;
                                                                                      • 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>
                                                                                      ) => any;
                                                                                      • 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>
                                                                                      ) => any;
                                                                                      • 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

                                                                                        {String} 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>
                                                                                        ) => 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>
                                                                                        ) => any;
                                                                                        • 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>) => any;
                                                                                        • Remove this wallet

                                                                                          Parameter params

                                                                                          Parameter callback

                                                                                          Returns

                                                                                          {*}

                                                                                        method removePolicyRule

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

                                                                                          Parameter params

                                                                                          Parameter callback

                                                                                          Returns

                                                                                          {*}

                                                                                        method removeUser

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

                                                                                          Parameter params

                                                                                          userId Id of the user to remove

                                                                                          Parameter callback

                                                                                          {*}

                                                                                        method removeWebhook

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

                                                                                          Parameter params

                                                                                          Parameter callback

                                                                                        method send

                                                                                        send: (params?: SendOptions, callback?: NodeCallback<any>) => 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.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>
                                                                                        ) => 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>
                                                                                        ) => 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>) => 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

                                                                                          {String} 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?: Record<string, never>,
                                                                                        callback?: NodeCallback<any>
                                                                                        ) => 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>) => any;
                                                                                        • 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>) => any;
                                                                                        • Share this wallet with another BitGo user.

                                                                                          Parameter params

                                                                                          Parameter callback

                                                                                          Returns

                                                                                          {*}

                                                                                        method signTransaction

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

                                                                                          Parameter params

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

                                                                                          Parameter callback

                                                                                          {*}

                                                                                        method simulateWebhook

                                                                                        simulateWebhook: (
                                                                                        params?: SimulateWebhookOptions,
                                                                                        callback?: NodeCallback<any>
                                                                                        ) => 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>
                                                                                        ) => 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>) => 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>) => any;
                                                                                        • List the transactions for a given wallet

                                                                                          Parameter params

                                                                                          Parameter callback

                                                                                          Returns

                                                                                          {*}

                                                                                        method transferBySequenceId

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

                                                                                          Parameter params

                                                                                          Parameter callback

                                                                                        method transferComment

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

                                                                                          Parameter params

                                                                                          Parameter callback

                                                                                          Returns

                                                                                          {*}

                                                                                        method transfers

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

                                                                                          Parameter params

                                                                                          Parameter callback

                                                                                          Returns

                                                                                          {*}

                                                                                        method unspents

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

                                                                                          Parameter params

                                                                                          Parameter callback

                                                                                          Returns

                                                                                          {*}

                                                                                        method updateAddress

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

                                                                                          Parameter params

                                                                                          Parameter callback

                                                                                          Returns

                                                                                          {*}

                                                                                        method updateTokenFlushThresholds

                                                                                        updateTokenFlushThresholds: (
                                                                                        thresholds?: any,
                                                                                        callback?: NodeCallback<any>
                                                                                        ) => 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>) => 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>) => 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>
                                                                                            ) => 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>
                                                                                            ) => any;
                                                                                            • 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>) => any;
                                                                                            • Get a wallet by ID (proxy for getWallet)

                                                                                              Parameter params

                                                                                              Parameter callback

                                                                                            method getShare

                                                                                            getShare: (
                                                                                            params?: { walletShareId?: string },
                                                                                            callback?: NodeCallback<any>
                                                                                            ) => 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>
                                                                                            ) => 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>) => any;
                                                                                            • Get a wallet by its ID

                                                                                              Parameter params

                                                                                              Parameter

                                                                                              params.id wallet id

                                                                                              Parameter callback

                                                                                              Returns

                                                                                              {*}

                                                                                            method getWalletByAddress

                                                                                            getWalletByAddress: (
                                                                                            params?: GetWalletByAddressOptions,
                                                                                            callback?: NodeCallback<Wallet>
                                                                                            ) => any;
                                                                                            • 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[] }>
                                                                                            ) => any;
                                                                                            • List a user's wallets

                                                                                              Parameter params

                                                                                              Parameter callback

                                                                                              Returns

                                                                                              {*}

                                                                                            method listShares

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

                                                                                              Parameter params

                                                                                              Parameter callback

                                                                                            method resendShareInvite

                                                                                            resendShareInvite: (
                                                                                            params?: { walletShareId?: string },
                                                                                            callback?: NodeCallback<any>
                                                                                            ) => 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>) => 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>) => any;
                                                                                                • Add new user webhook

                                                                                                  Parameter params

                                                                                                  Parameter callback

                                                                                                  Returns

                                                                                                  {*}

                                                                                                method list

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

                                                                                                  Parameter callback

                                                                                                  Returns

                                                                                                  {*}

                                                                                                method listNotifications

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

                                                                                                  Parameter params

                                                                                                  Parameter callback

                                                                                                  Returns

                                                                                                  {*}

                                                                                                method remove

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

                                                                                                  Parameter params

                                                                                                  Parameter callback

                                                                                                  Returns

                                                                                                  {*}

                                                                                                method simulate

                                                                                                simulate: (params: SimulateOptions, callback: NodeCallback<any>) => 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 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, callback?: NodeCallback<superagent.Response>) => BitGoRequest;

                                                                                                                                                                                                                                                      method get

                                                                                                                                                                                                                                                      get: (url: string, callback?: NodeCallback<superagent.Response>) => BitGoRequest;

                                                                                                                                                                                                                                                        method patch

                                                                                                                                                                                                                                                        patch: (
                                                                                                                                                                                                                                                        url: string,
                                                                                                                                                                                                                                                        callback?: NodeCallback<superagent.Response>
                                                                                                                                                                                                                                                        ) => BitGoRequest;

                                                                                                                                                                                                                                                          method post

                                                                                                                                                                                                                                                          post: (
                                                                                                                                                                                                                                                          url: string,
                                                                                                                                                                                                                                                          callback?: NodeCallback<superagent.Response>
                                                                                                                                                                                                                                                          ) => BitGoRequest;

                                                                                                                                                                                                                                                            method put

                                                                                                                                                                                                                                                            put: (url: string, callback?: NodeCallback<superagent.Response>) => BitGoRequest;

                                                                                                                                                                                                                                                              interface BitGoJson

                                                                                                                                                                                                                                                              interface BitGoJson {}

                                                                                                                                                                                                                                                                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 BitGoRequest

                                                                                                                                                                                                                                                                                                          interface BitGoRequest extends superagent.Request {}

                                                                                                                                                                                                                                                                                                            property end

                                                                                                                                                                                                                                                                                                            end: (callback?: NodeCallback<superagent.Response>) => void;

                                                                                                                                                                                                                                                                                                              property result

                                                                                                                                                                                                                                                                                                              result: (optionalField?: string) => Bluebird<any>;

                                                                                                                                                                                                                                                                                                                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 forwarderVersion

                                                                                                                                                                                                                                                                                                                                                                                                                    forwarderVersion?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                      property gasPrice

                                                                                                                                                                                                                                                                                                                                                                                                                      gasPrice?: number | string;

                                                                                                                                                                                                                                                                                                                                                                                                                        property label

                                                                                                                                                                                                                                                                                                                                                                                                                        label?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                          property lowPriority

                                                                                                                                                                                                                                                                                                                                                                                                                          lowPriority?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                            interface CreateBackupOptions

                                                                                                                                                                                                                                                                                                                                                                                                                            interface CreateBackupOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                              property disableKRSEmail

                                                                                                                                                                                                                                                                                                                                                                                                                              disableKRSEmail?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                property krsSpecific

                                                                                                                                                                                                                                                                                                                                                                                                                                krsSpecific?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property provider

                                                                                                                                                                                                                                                                                                                                                                                                                                  provider?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property reqId

                                                                                                                                                                                                                                                                                                                                                                                                                                    reqId?: RequestTracer;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property source

                                                                                                                                                                                                                                                                                                                                                                                                                                      source?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                        type?: string;