Options
All
  • Public
  • Public/Protected
  • All
Menu

Hierarchy

Index

Constructors

constructor

Properties

homeDomain

homeDomain: string

Static maxMemoId

maxMemoId: string = "0xFFFFFFFFFFFFFFFF"

Static maxTrustlineLimit

maxTrustlineLimit: string = "9223372036854775807"

Static tokenPatternSeparator

tokenPatternSeparator: "-" = "-"

Accessors

type

  • get type(): string

Static coinTokenPatternSeparator

  • get coinTokenPatternSeparator(): string

Methods

allowsAccountConsolidations

  • allowsAccountConsolidations(): boolean

baseUnitsToBigUnits

  • baseUnitsToBigUnits(baseUnits: string | number): string

bigUnitsToBaseUnits

  • bigUnitsToBaseUnits(bigUnits: string | number): string

deriveKeyWithSeed

  • deriveKeyWithSeed(__namedParameters: object): object
  • Derive a hardened child public key from a master key seed using an additional seed for randomness.

    Due to technical differences between keypairs on the ed25519 curve and the secp256k1 curve, only hardened private key derivation is supported.

    Parameters

    • __namedParameters: object

    Returns object

enterprises

explainTransaction

  • explainTransaction(params: ExplainTransactionOptions, callback?: NodeCallback<TransactionExplanation>): Bluebird<TransactionExplanation>

federationLookupByAccountId

  • federationLookupByAccountId(accountId: string): Bluebird<Record>
  • Attempt to resolve an account id into a stellar account Only works for accounts that can be resolved by our federation server

    Parameters

    • accountId: string

      stellar account id

    Returns Bluebird<Record>

federationLookupByName

  • federationLookupByName(address: string): Bluebird<Record>

feeEstimate

generateKeyPair

  • generateKeyPair(seed: Buffer): KeyPair

getAddressDetails

  • getAddressDetails(address: string): AddressDetails

getBaseFactor

  • getBaseFactor(): number

getBaseTransactionFee

  • getBaseTransactionFee(): Bluebird<number>

getBitGoFederationServer

  • getBitGoFederationServer(): FederationServer

getChain

  • getChain(): string

getExtraPrebuildParams

getFamily

  • getFamily(): string

getFederationServerUrl

  • getFederationServerUrl(): string

getFullName

  • getFullName(): string

getHorizonUrl

  • getHorizonUrl(): string

getMinimumReserve

  • getMinimumReserve(): Bluebird<number>

getPrvFromRaw

  • getPrvFromRaw(prv: string): string

getPubFromRaw

  • getPubFromRaw(pub: string): string

getTokenNameFromStellarAsset

  • getTokenNameFromStellarAsset(asset: stellar.Asset): string

initiateRecovery

  • initiateRecovery(params: RecoveryOptions): Bluebird<stellar.Keypair[]>

isValidAddress

  • isValidAddress(address: string): boolean

isValidMemo

  • isValidMemo(__namedParameters: object): boolean

isValidMemoId

  • isValidMemoId(memoId: string): boolean

isValidMofNSetup

  • isValidMofNSetup(__namedParameters: object): boolean

isValidPrv

  • isValidPrv(prv: string): boolean

isValidPub

  • isValidPub(pub: string): boolean

isValidStellarUsername

  • isValidStellarUsername(username: string): boolean
  • Evaluate whether a stellar username has valid format This method is used by the client when a stellar address is being added to a wallet Example of a common stellar username: foo@bar.baz The above example would result in the Stellar address: foo@bar.baz*bitgo.com

    Parameters

    • username: string

      stellar username

    Returns boolean

    true if stellar username is valid

keyIdsForSigning

  • keyIdsForSigning(): number[]

keychains

markets

newWalletObject

  • newWalletObject(walletParams: any): Wallet

normalizeAddress

  • normalizeAddress(__namedParameters: object): string

parseTransaction

pendingApprovals

postProcessPrebuild

preCreateBitGo

presignTransaction

recover

  • recover(params: RecoveryOptions, callback: NodeCallback<RecoveryTransaction>): Bluebird<RecoveryTransaction>
  • Builds a funds recovery transaction without BitGo

    Parameters

    • params: RecoveryOptions
      • userKey: [encrypted] Stellar private key
      • backupKey: [encrypted] Stellar private key, or public key if the private key is held by a KRS provider
      • walletPassphrase: necessary if one of the private keys is encrypted
      • rootAddress: base address of the wallet to recover funds from
      • krsProvider: necessary if backup key is held by KRS
      • recoveryDestination: target address to send recovered funds to
    • callback: NodeCallback<RecoveryTransaction>

    Returns Bluebird<RecoveryTransaction>

signMessage

  • signMessage(key: KeyPair, message: string | Buffer, callback?: NodeCallback<Buffer>): Bluebird<Buffer>

signTransaction

  • signTransaction(params: SignTransactionOptions, callback?: NodeCallback<HalfSignedTransaction>): Bluebird<HalfSignedTransaction>

supplementGenerateWallet

  • supplementGenerateWallet(walletParams: SupplementGenerateWalletOptions): Bluebird<SupplementGenerateWalletOptions>
  • Extend walletParams with extra params required for generating an XLM wallet

    Stellar wallets have three keychains on them. Two are generated by the platform, and the last is generated by the user. Initially, we need a root prv to generate the account, which must be distinct from all three keychains on the wallet. If a root prv is not provided, a random one is generated.

    Parameters

    • walletParams: SupplementGenerateWalletOptions

    Returns Bluebird<SupplementGenerateWalletOptions>

supportsBlockTarget

  • supportsBlockTarget(): boolean

transactionDataAllowed

  • transactionDataAllowed(): boolean

url

  • url(suffix: string): string

valuelessTransferAllowed

  • valuelessTransferAllowed(): boolean

verifyAddress

  • verifyAddress(__namedParameters: object): boolean

verifyRecoveryTransaction

verifySignature

  • verifySignature(pub: string, message: string | Buffer, signature: Buffer): any
  • Verifies if signature for message is valid.

    Parameters

    • pub: string

      public key

    • message: string | Buffer

      signed message

    • signature: Buffer

      signature to verify

    Returns any

    true if signature is valid.

verifyTransaction

  • verifyTransaction(options: VerifyTransactionOptions, callback?: NodeCallback<boolean>): Bluebird<boolean>

verifyTrustlineTxOperations

  • verifyTrustlineTxOperations(operations: stellar.Operation[], txParams: TransactionParams): void
  • Verify that a tx prebuild's operations comply with the original intention

    Parameters

    • operations: stellar.Operation[]

      tx operations

    • txParams: TransactionParams

      params used to build the tx

    Returns void

wallets

webhooks

Static createInstance

Generated using TypeDoc