Options
All
  • Public
  • Public/Protected
  • All
Menu

waves-transactions

Index

Type aliases

CancellablePromise

CancellablePromise: Promise<T> & object

TOption

TOption: T | undefined | null

TOrder

TSeedTypes

TSeedTypes: string | TOption<string>[] | IIndexSeedMap

TTx

TTxParams

Functions

accountData

  • accountData(address: string, nodeUrl: string): Promise<Record<string, IDataEntry>>
  • Get full account dictionary

    Parameters

    Returns Promise<Record<string, IDataEntry>>

accountDataByKey

  • accountDataByKey(key: string, address: string, nodeUrl: string): Promise<IDataEntry>
  • Get data from account dictionary by key

    Parameters

    • key: string

      dictionary key

    • address: string

      waves address as base58 string

    • nodeUrl: string

      node address to ask data from. E.g. https://nodes.wavesplatform.com/

    Returns Promise<IDataEntry>

alias

  • Creates and signs IAliasTransaction.

    If no senderPublicKey is set, it will be derived from seed. In case sender and signer are different, you need to pass senderPublicKey explicitly.

    You can use this function with multiple seeds. In this case it will sign transaction accordingly and will add one proof per seed. Also you can use already formed IAliasTransaction instead of params.

    Usage

    const { alias } = require('@waves/waves-transactions')
    
    const seed = 'example seed phrase'
    
    const params = {
      alias: 'MyNewAlias',
      chainId: 'W',
      //senderPublicKey: 'by default derived from seed',
      //timestamp: Date.now(),
      //fee: 100000,
    }
    
    const signedAliasTx = alias(params, seed)

    Output

    {
      "id": "3U4NWo2q7JBizRRpSss5VMUBJH6FS8XFRKUJ6Ei6HGxL",
      "type": 10,
      "version": 2,
      "senderPublicKey": "3SU7zKraQF8tQAF8Ho75MSVCBfirgaQviFXnseEw4PYg",
      "alias": "MyNewAlias",
      "fee": 100000,
      "timestamp": 1559744696562,
      "chainId": 87,
      "proofs": [
        "5QGAzNX9Azm59HtHck6e7rJjrpGoFMi78f4d1bNdgaJz25xGSd6zuNaK8Frzf2iFc28kKL2kMfokVZLo8ZTsaei8"
      ]
    }

    Parameters

    Returns IAliasTransaction & WithId

  • Parameters

    Returns IAliasTransaction & WithId

assetBalance

  • assetBalance(assetId: string, address: string, nodeUrl: string): Promise<any>
  • Retrieve information about specific asset account balance

    Parameters

    • assetId: string

      id of asset

    • address: string

      waves address as base58 string

    • nodeUrl: string

      node address to ask balance from. E.g. https://nodes.wavesplatform.com/

    Returns Promise<any>

balance

  • balance(address: string, nodeUrl: string): Promise<number>
  • Get account effective balance

    Parameters

    Returns Promise<number>

balanceDetails

  • balanceDetails(address: string, nodeUrl: string): Promise<any>
  • Retrieve full information about waves account balance. Effective, generating etc

    Parameters

    Returns Promise<any>

broadcast

  • broadcast(tx: TTx, nodeUrl: string): Promise<any>
  • Sends transaction to waves node

    Parameters

    Returns Promise<any>

burn

  • Creates and signs IBurnTransaction.

    If no senderPublicKey is set, it will be derived from seed. In case sender and signer are different, you need to pass senderPublicKey explicitly.

    You can use this function with multiple seeds. In this case it will sign transaction accordingly and will add one proof per seed. Also you can use already formed IBurnTransaction instead of params.

    Usage

    const { burn } = require('@waves/waves-transactions')
    
    const seed = 'example seed phrase'
    
    const params = {
      assetId: '4uK8i4ThRGbehENwa6MxyLtxAjAo1Rj9fduborGExarC',
      quantity: 100,
      //senderPublicKey: 'by default derived from seed',
      //timestamp: Date.now(),
      //fee: 100000,
      //chainId: 'W',
    }
    
    const signedBurnTx = burn(params, seed)

    Output

    {
      "id": "4NTvSAbXCcFKdGTzzAzoJ2zQNrjWAWWGS4oaZBa1gvRo",
      "type": 6,
      "version": 2,
      "senderPublicKey": "3SU7zKraQF8tQAF8Ho75MSVCBfirgaQviFXnseEw4PYg",
      "assetId": "4uK8i4ThRGbehENwa6MxyLtxAjAo1Rj9fduborGExarC",
      "quantity": 100,
      "chainId": 87,
      "fee": 100000,
      "timestamp": 1559744696368,
      "proofs": [
        "3J2ov9w5m1K2kDXkbAhJGUaVfmjV225c92MDdY7igVi5653oMN9pB8T4hsxgpShHxXFrfjiyUjykPYRYaQbF2K2z"
      ]
    }

    Parameters

    Returns IBurnTransaction & WithId

  • Parameters

    Returns IBurnTransaction & WithId

cancelLease

  • Creates and signs ICancelLeaseTransaction.

    If no senderPublicKey is set, it will be derived from seed. In case sender and signer are different, you need to pass senderPublicKey explicitly.

    You can use this function with multiple seeds. In this case it will sign transaction accordingly and will add one proof per seed. Also you can use already formed ICancelLeaseTransaction instead of params.

    Usage

    const { cancelLease } = require('@waves/waves-transactions')
    
    const seed = 'example seed phrase'
    
    const params = {
      leaseId: '2fYhSNrXpyKgbtHzh5tnpvnQYuL7JpBFMBthPSGFrqqg',
      //senderPublicKey: 'by default derived from seed',
      //timestamp: Date.now(),
      //fee: 100000,
      //chainId: 'W'
    }
    
    const signedCancelLeaseTx = cancelLease(params, seed)

    Output

    {
      "id": "AsTanWa6q6TgEgK4Vzre4t1BPfL5iQ9YovaTn21X1bej",
      "type": 9,
      "version": 2,
      "senderPublicKey": "3SU7zKraQF8tQAF8Ho75MSVCBfirgaQviFXnseEw4PYg",
      "leaseId": "2fYhSNrXpyKgbtHzh5tnpvnQYuL7JpBFMBthPSGFrqqg",
      "fee": 100000,
      "timestamp": 1559744696419,
      "chainId": 87,
      "proofs": [
        "b3pHdtqMbHTcr7dkAbsnGi3bLBttVS6a5j8N8svJe5hgFfhBw5EXWWVLaKznLC8wJ8cV75ksD8GNKgV483mrCAF"
      ]
    }

    Parameters

    Returns ICancelLeaseTransaction & WithId

  • Parameters

    Returns ICancelLeaseTransaction & WithId

cancelOrder

Const cancelOrderParamsToBytes

  • cancelOrderParamsToBytes(cancelOrderParams: object): Uint8Array
  • Parameters

    • cancelOrderParams: object

    Returns Uint8Array

cancelSubmittedOrder

  • cancelSubmittedOrder(co: ICancelOrder, amountAsset: string | null, priceAsset: string | null, matcherUrl: string): Promise<any>
  • Sends cancel order command to matcher. Since matcher api requires amountAsset and priceAsset in request url, this function requires them as params

    Parameters

    • co: ICancelOrder

      signed cancelOrder object

    • amountAsset: string | null

      amount asset of the order to be canceled

    • priceAsset: string | null

      price asset of the order to be canceled

    • matcherUrl: string

      matcher address to send order cancel to. E.g. https://matcher.wavesplatform.com/

    Returns Promise<any>

Const currentHeight

  • currentHeight(apiBase: string): Promise<number>
  • Parameters

    • apiBase: string

    Returns Promise<number>

data

  • Creates and signs IDataTransaction.

    If no senderPublicKey is set, it will be derived from seed. In case sender and signer are different, you need to pass senderPublicKey explicitly.

    You can use this function with multiple seeds. In this case it will sign transaction accordingly and will add one proof per seed. Also you can use already formed IDataTransaction instead of params.

    Usage

    const { data } = require('@waves/waves-transactions')
    
    const seed = 'example seed phrase'
    
    const params = {
      data: [
        { key: 'integerVal', value: 1 },
        { key: 'booleanVal', value: true },
        { key: 'stringVal', value: 'hello' },
        { key: 'binaryVal', value: [1, 2, 3, 4] },
      ],
      //senderPublicKey: 'by default derived from seed',
      //timestamp: Date.now(),
      //fee: 100000 + bytes.length * 100000
    }
    
    const signedDataTx = data(params, seed)

    Output

    {
      "id": "V69hJavU1meXorPLxHbsHEjDHVp6R7hjeoxYJuXEFgt",
      "type": 12,
      "version": 1,
      "senderPublicKey": "3SU7zKraQF8tQAF8Ho75MSVCBfirgaQviFXnseEw4PYg",
      "fee": 100000,
      "timestamp": 1559744696443,
      "proofs": [
        "5St6YLZHVd2svwWiGQ5pMWY3RiTA7c5TQDxwwsxuyropgxa9j7eWgs8AdhPWPymtB827BVJwSVwxhPG6FZyaW6Kj"
      ],
      "data": [
        {
          "type": "integer",
          "key": "integerVal",
          "value": 1
        },
        {
          "type": "boolean",
          "key": "booleanVal",
          "value": true
        },
        {
          "type": "string",
          "key": "stringVal",
          "value": "hello"
        },
        {
          "type": "binary",
          "key": "binaryVal",
          "value": "base64:AQIDBA=="
        }
      ]
    }

    Parameters

    Returns IDataTransaction & WithId

  • Parameters

    Returns IDataTransaction & WithId

exchange

invokeScript

issue

  • Creates and signs IIssueTransaction.

    If no senderPublicKey is set, it will be derived from seed. In case sender and signer are different, you need to pass senderPublicKey explicitly.

    You can use this function with multiple seeds. In this case it will sign transaction accordingly and will add one proof per seed. Also you can use already formed IIssueTransaction instead of params.

    Usage

    const { issue } = require('@waves/waves-transactions')
    
    const seed = 'seed phrase of fifteen words'
    
    const params = {
      name: 'HotPotato TOKEN',
      description: 'It is a gaming token',
      quantity: 1000000,
      //senderPublicKey: 'by default derived from seed',
      //reissuable: false
      //decimals: 8
      //timestamp: Date.now(),
      //fee: 100000000,
      //chainId: 'W'
    }
    
    const signedIssueTx = issue(params, seed)
    console.log(signedIssueTx)

    Output

    {
      "id": "9N8GZ9zJHjuVE4Y57bRcJmQ4bjeHhoaH1JoCBh9Bb4qH",
      "type": 3,
      "version": 2,
      "senderPublicKey": "HRQUmzJKgHDGbsfS23kSA1VRuudy5MY3wGCroUmNhKuJ",
      "name": "HotPotato TOKEN",
      "description": "It is a gaming token",
      "quantity": 1000000,
      "decimals": 8,
      "reissuable": false,
      "fee": 100000000,
      "timestamp": 1559744696463,
      "chainId": 87,
      "proofs": [
        "54hf17cNpbgqbG4ec2jNisW511Em8D82sMCs4hVowczTbtByxW38Kz562mHjzZpHxA6GuAMGv1Lon7shHtkpdGfS"
      ]
    }

    Parameters

    Returns IIssueTransaction & WithId

  • Parameters

    Returns IIssueTransaction & WithId

lease

  • Creates and signs ILeaseTransaction.

    If no senderPublicKey is set, it will be derived from seed. In case sender and signer are different, you need to pass senderPublicKey explicitly.

    You can use this function with multiple seeds. In this case it will sign transaction accordingly and will add one proof per seed. Also you can use already formed ILeaseTransaction instead of params.

    Usage

    const { lease } = require('@waves/waves-transactions')
    
    const seed = 'example seed phrase'
    
    const params = {
      amount: 100,
      recipient: '3P23fi1qfVw6RVDn4CH2a5nNouEtWNQ4THs',
      //senderPublicKey: 'by default derived from seed',
      //timestamp: Date.now(),
      //fee: 100000,
    }
    
    const signedLeaseTx = lease(params, seed)

    Output

    {
      "id": "DLhVm8BM1GJk5Gn4rzDEADQwznEXRukDq1MugzohQf55",
      "type": 8,
      "version": 2,
      "senderPublicKey": "3SU7zKraQF8tQAF8Ho75MSVCBfirgaQviFXnseEw4PYg",
      "amount": 100,
      "recipient": "3P23fi1qfVw6RVDn4CH2a5nNouEtWNQ4THs",
      "fee": 100000,
      "timestamp": 1559744696493,
      "proofs": [
        "2EmzLfPGwuEoPL88XgkKCcb6uha5wZHHhcAKSusSizEEyNTF1roZSuhMzMVTvCnX2dr4bGttJBwaLcpQ8rWvZcBj"
      ]
    }

    Parameters

    Returns ILeaseTransaction & WithId

  • Parameters

    Returns ILeaseTransaction & WithId

massTransfer

  • Creates and signs IMassTransferTransaction.

    If no senderPublicKey is set, it will be derived from seed. In case sender and signer are different, you need to pass senderPublicKey explicitly.

    You can use this function with multiple seeds. In this case it will sign transaction accordingly and will add one proof per seed. Also you can use already formed IMassTransferTransaction instead of params.

    Usage

    const { massTransfer } = require('@waves/waves-transactions')
    
    const seed = 'example seed phrase'
    
    const params = {
      transfers: [
        {
          amount: 100,
          recipient: '3P23fi1qfVw6RVDn4CH2a5nNouEtWNQ4THs',
        },
        {
          amount: 200,
          recipient: '3PPnqZznWJbPG2Z1Y35w8tZzskiq5AMfUXr',
        },
      ],
      //senderPublicKey: 'by default derived from seed',
      //timestamp: Date.now(),
      //fee: 100000 + transfers.length * 50000,
    }
    
    const signedMassTransferTx = massTransfer(params, seed)

    Output

    {
      "id": "oXHehGuL2HL61CewGVCr6UNsrULeE5raTAX9r2BMKFu",
      "type": 11,
      "version": 1,
      "senderPublicKey": "3SU7zKraQF8tQAF8Ho75MSVCBfirgaQviFXnseEw4PYg",
      "transfers": [
        {
          "amount": 100,
          "recipient": "3P23fi1qfVw6RVDn4CH2a5nNouEtWNQ4THs"
        },
        {
          "amount": 200,
          "recipient": "3PPnqZznWJbPG2Z1Y35w8tZzskiq5AMfUXr"
        }
      ],
      "fee": 200000,
      "timestamp": 1559744696507,
      "attachment": "",
      "proofs": [
        "3xrjW9qxyHwVmFJR7XbFSV94aTBrVi7fS4E1wCLKyVrVocV9Gg6AxpXcLDxWGbegwTMqEYmphQainyYhnFBE8hMx"
      ]
    }

    Parameters

    Returns IMassTransferTransaction & WithId

  • Parameters

    Returns IMassTransferTransaction & WithId

order

  • Creates and signs [[Order]].

    You can use this function with multiple seeds. In this case it will sign order accordingly and will add one proof per seed. Also you can use already signed [[Order]] as a second agrument.

    Usage

    const { order } = require('waves-transactions')
    
    const seed = 'b716885e9ba64442b4f1263c8e2d8671e98b800c60ec4dc2a27c83e5f9002b18'
    
    const params = {
      amount: 100000000, //1 waves
      price: 10, //for 0.00000010 BTC
      priceAsset: '8LQW8f7P5d5PZM7GtZEBgaqRPGSzS3DfPuiXrURJ4AJS',
      matcherPublicKey: '7kPFrHDiGw1rCm7LPszuECwWYL3dMf6iMifLRDJQZMzy',
      orderType: 'buy'
    }
    
    
    const signedOrder = order(params, seed)

    Output

    {
      "id": "47YGqHdHtNPjcjE69E9EX9aD9bpC8PRKr4kp5AcZKHFq",
      "orderType": "buy",
      "assetPair": {
        "priceAsset": "8LQW8f7P5d5PZM7GtZEBgaqRPGSzS3DfPuiXrURJ4AJS"
      },
      "price": 10,
      "amount": 100000000,
      "timestamp": 1540898977249,
      "expiration": 1542626977249,
      "matcherFee": 300000,
      "matcherPublicKey": "7kPFrHDiGw1rCm7LPszuECwWYL3dMf6iMifLRDJQZMzy",
      "senderPublicKey": "G62H1XE5rnaCgCCURV5pWwQHzWezZB7VkkVgqthdKgkj",
      "proofs": [
        "4MbaDLkx9ezV1DrcGRfXRfnMBtYLaeLYBe6YGqkkuq1Pe6U9Qc5Cv7Fy1zYyGatbg47U5j374iAQFbLLZiYBChgU"
      ]
    }

    Parameters

    Returns TOrder & WithId

  • Parameters

    Returns TOrder & WithId

reissue

  • Creates and signs IReissueTransaction.

    If no senderPublicKey is set, it will be derived from seed. In case sender and signer are different, you need to pass senderPublicKey explicitly.

    You can use this function with multiple seeds. In this case it will sign transaction accordingly and will add one proof per seed. Also you can use already formed IReissueTransaction instead of params.

    Usage

    const { reissue } = require('@waves/waves-transactions')
    
    const seed = 'example seed phrase'
    
    const params = {
      quantity: 10000,
      assetId: '3toqCSpAHShatE75UFKxqymuWFr8nxuxD7UcLjdxVFLx',
      reissuable: false,
      //senderPublicKey: 'by default derived from seed',
      //timestamp: Date.now(),
      //fee: 100000000,
      //chainId: 'W'
    }
    
    const signedReissueTx = reissue(params, seed)

    Output

    {
      "id": "45S9CX75gr7ochdar7spx4368d9HLbpoCamUeZCdWtpD",
      "type": 5,
      "version": 2,
      "senderPublicKey": "3SU7zKraQF8tQAF8Ho75MSVCBfirgaQviFXnseEw4PYg",
      "assetId": "3toqCSpAHShatE75UFKxqymuWFr8nxuxD7UcLjdxVFLx",
      "quantity": 10000,
      "reissuable": false,
      "chainId": 87,
      "fee": 100000000,
      "timestamp": 1559744696521,
      "proofs": [
        "4m1FxGrDVcm6Ps1sRfVgRBXvSToTcV3AZJbhHP5YeZnyqKQVgFfwmRShNRMM6m3fRmV6DDGv8muZyJA4JqmrFCjz"
      ]
    }

    Parameters

    Returns IReissueTransaction & WithId

  • Parameters

    Returns IReissueTransaction & WithId

scriptInfo

  • scriptInfo(address: string, nodeUrl: string): Promise<any>
  • Get account script info

    Parameters

    Returns Promise<any>

serialize

  • Converts transaction or order object to Uint8Array

    Parameters

    Returns Uint8Array

setAssetScript

setScript

  • Creates and signs ISetScriptTransaction.

    If no senderPublicKey is set, it will be derived from seed. In case sender and signer are different, you need to pass senderPublicKey explicitly.

    You can use this function with multiple seeds. In this case it will sign transaction accordingly and will add one proof per seed. Also you can use already formed ISetScriptTransaction instead of params.

    Usage

    const { setScript } = require('@waves/waves-transactions')
    
    const seed = 'example seed phrase'
    
    const params = {
      script: 'AQa3b8tH', //true
      //senderPublicKey: 'by default derived from seed',
      //timestamp: Date.now(),
      //fee: 100000,
      //chainId: 'W'
    }
    
    const signedSetScriptTx = setScript(params, seed)

    Output

    {
      "id": "AhMusXxWuecCPjgRVarGvPtsuqtwG3eWfAjDEGxWXGRG",
      "type": 13,
      "version": 1,
      "senderPublicKey": "3SU7zKraQF8tQAF8Ho75MSVCBfirgaQviFXnseEw4PYg",
      "chainId": 87,
      "fee": 1000000,
      "timestamp": 1559744696578,
      "proofs": [
        "253kE4sF1iGwv7oC2Aw2vHxQwMv856z4WWRkvjHVqHBKrStruLnmSHX9D6sJwUKL7zLvWc7ihSA8oq8DFUEpcuup"
      ],
      "script": "base64:AQa3b8tH"
    }

    Parameters

    Returns ISetScriptTransaction & WithId

  • Parameters

    Returns ISetScriptTransaction & WithId

signTx

  • Signs arbitrary transaction. Can also create signed transaction if provided params have type field

    Parameters

    Returns TTx

sponsorship

  • Creates and signs ISponsorshipTransaction.

    If no senderPublicKey is set, it will be derived from seed. In case sender and signer are different, you need to pass senderPublicKey explicitly.

    You can use this function with multiple seeds. In this case it will sign transaction accordingly and will add one proof per seed. Also you can use already formed ISponsorshipTransaction instead of params.

    Usage

    const { sponsorship } = require('@waves/waves-transactions')
    
    const seed = 'example seed phrase'
    
    const params = {
      assetId: '4uK8i4ThRGbehENwa6MxyLtxAjAo1Rj9fduborGExarC',
      minSponsoredAssetFee: 100,
      //senderPublicKey: 'by default derived from seed',
      //timestamp: Date.now(),
      //fee: 100000,
      //chainId: 'W',
    }
    
    const signedSponsorshipTx = sponsorship(params, seed)

    Output

    {
      "id": "HwHGSfcrLY7A9xADkmP8qyp9rrHzNmmHYrdvmvDja1gn",
      "type": 14,
      "version": 1,
      "senderPublicKey": "3SU7zKraQF8tQAF8Ho75MSVCBfirgaQviFXnseEw4PYg",
      "minSponsoredAssetFee": 100,
      "assetId": "4uK8i4ThRGbehENwa6MxyLtxAjAo1Rj9fduborGExarC",
      "fee": 100000000,
      "timestamp": 1559744696594,
      "proofs": [
        "5Lp3jr7UynKcYuk7QP825tjTQ987L3v98uP7Tyq4W68gTccctXXMP4g7eWJBVHiFe2bVUDrSXDApfoKKJRJiZA3W"
      ]
    }

    Parameters

    Returns ISponsorshipTransaction & WithId

  • Parameters

    Returns ISponsorshipTransaction & WithId

stateChanges

  • Get invokeScript tx state changes

    Parameters

    Returns Promise<IStateChangeResponse>

submitOrder

  • submitOrder(ord: TOrder, matcherUrl: string): Promise<any>
  • Sends order to matcher

    Parameters

    Returns Promise<any>

transfer

  • Creates and signs ITransferTransaction.

    If no senderPublicKey is set, it will be derived from seed. In case sender and signer are different, you need to pass senderPublicKey explicitly.

    You can use this function with multiple seeds. In this case it will sign transaction accordingly and will add one proof per seed. Also you can use already formed ITransferTransaction instead of params.

    Usage

    const { transfer } = require('@waves/waves-transactions')
    
    const seed = 'example seed phrase'
    
    //Transfering 1 WAVES
    const params = {
      amount: 100000000,
      recipient: '3P23fi1qfVw6RVDn4CH2a5nNouEtWNQ4THs',
      //feeAssetId: undefined
      //assetId: undefined
      //attachment: undefined
      //senderPublicKey: 'by default derived from seed',
      //timestamp: Date.now(),
      //fee: 100000,
    }
    
    const signedTransferTx = transfer(params, seed)

    Output

    {
      "id": "HocAgwszXeB5o9jYnoCUXJ3CY2pr6MfpYjzRGcVYvqxU",
      "type": 4,
      "version": 2,
      "senderPublicKey": "3SU7zKraQF8tQAF8Ho75MSVCBfirgaQviFXnseEw4PYg",
      "recipient": "3P23fi1qfVw6RVDn4CH2a5nNouEtWNQ4THs",
      "amount": 100000000,
      "attachment": "",
      "fee": 100000,
      "timestamp": 1559744696548,
      "proofs": [
        "4u2Fdegc2dm7JgnKBK3GfX3aeYHNtLtuYGfmvaPSD7x9mLMkHsS6PaHtvFDmBT2TREBs6rsnrLgW3VmRLTKmUEsg"
      ]
    }

    Parameters

    Returns ITransferTransaction & WithId

  • Parameters

    Returns ITransferTransaction & WithId

verify

  • verify(obj: TTx | TOrder, proofN?: number, publicKey?: undefined | string): boolean
  • Verifies signature of transaction or order

    Parameters

    • obj: TTx | TOrder
    • Default value proofN: number = 0

      proof index. Takes first proof by default

    • Optional publicKey: undefined | string

      takes senderPublicKey by default

    Returns boolean

waitForHeight

  • Parameters

    Returns Promise<number>

waitForTx

  • Resolves when specified txId is mined into block

    Parameters

    Returns Promise<TTx>

waitForTxWithNConfirmations

  • waitForTxWithNConfirmations(txId: string, confirmations: number, options: INodeRequestOptions): Promise<TTx>
  • Parameters

    Returns Promise<TTx>

waitNBlocks

  • Parameters

    • blocksCount: number
    • Default value options: INodeRequestOptions = DEFAULT_NODE_REQUEST_OPTIONS

    Returns Promise<number>

Object literals

Const txTypeMap

txTypeMap: object

__computed

__computed: object

sign

Generated using TypeDoc