Class Transaction

    Transaction class representing a Klever blockchain transaction Extends the protobuf Transaction class with convenience methods

    This class wraps the proto-generated Transaction and provides:

    • Easy signing with private keys
    • Serialization to bytes/hex
    • Fee calculations
    • Transaction state management

    This is a pure data class - no network dependencies. Use provider.sendRawTransaction(tx.toHex()) to broadcast.

    Hierarchy
    • Transaction
      • Transaction

    Constructors

    constructor

    Properties

    Block GasLimit GasMultiplier RawData? Receipts Result ResultCode Signature

    Methods

    getHash getHashBytes getTotalFee isSigned sign toBytes toHex toJSON create decode decodeDelimited encode encodeDelimited fromBytes fromHex fromObject fromTransaction getTypeUrl toObject verify

    Constructors

    constructor

    Properties

    Block

    Block: number

    Transaction Block.

    GasLimit

    GasLimit: number

    Transaction GasLimit.

    GasMultiplier

    GasMultiplier: number

    Transaction GasMultiplier.

    OptionalRawData

    RawData?: null | IRaw

    Transaction RawData.

    Receipts

    Receipts: IReceipt[]

    Transaction Receipts.

    Result

    Result: TXResult

    Transaction Result.

    ResultCode

    ResultCode: TXResultCode

    Transaction ResultCode.

    Signature

    Signature: Uint8Array<ArrayBufferLike>[]

    Transaction Signature.

    Methods

    getHash

    • getHash(): string

      Get the transaction hash Computes blake2b hash of the RawData proto bytes

      Returns string

      Transaction hash as hex string

      Example

      const tx = new Transaction(txData)
      const hash = tx.getHash()
      // hash: "a3f2e8d9..."

    getHashBytes

    • getHashBytes(): Uint8Array

      Get the transaction hash bytes Computes blake2b hash of the RawData proto bytes

      Returns Uint8Array

      Transaction hash as Uint8Array

      Example

      const tx = new Transaction(txData)
      const hashBytes = tx.getHashBytes()
      // Use for signing or other operations

    getTotalFee

    • getTotalFee(): bigint

      Get total fee (KAppFee + BandwidthFee) Returns the combined fee for the transaction in smallest KLV units

      Returns bigint

      Total fee amount in KLV smallest units (1 KLV = 1,000,000 units)

      Example

      const tx = new Transaction(txData)
      const totalFee = tx.getTotalFee()
      console.log(`Total fee: ${totalFee} units`) // e.g., "600000 units"

      // Convert to human-readable KLV
      const feeInKLV = Number(totalFee) / 1_000_000
      console.log(`Fee: ${feeInKLV} KLV`) // e.g., "0.6 KLV"

    isSigned

    • isSigned(): boolean

      Check if transaction is signed Verifies whether the transaction has been signed and is ready for broadcast

      Returns boolean

      true if transaction has at least one signature, false otherwise

      Example

      const tx = new Transaction(txData)
      console.log(tx.isSigned()) // false

      await tx.sign(privateKey)
      console.log(tx.isSigned()) // true

      // Only broadcast if signed
      if (tx.isSigned()) {
        await provider.sendRawTransaction(tx.toHex())
      }

    sign

    • sign(privateKey: PrivateKey): Promise<Transaction>

      Sign the transaction with a private key Signs the transaction hash (blake2b of RawData)

      Parameters

      • privateKey: PrivateKey

        Private key to sign with

      Returns Promise<Transaction>

      This transaction instance with signature added

      Example

      const tx = new Transaction(txData)
      await tx.sign(privateKey)
      // tx now has Signature field populated

    toBytes

    • toBytes(): Uint8Array

      Get raw proto bytes for the transaction This is what gets signed and broadcast to the network

      Returns Uint8Array

      Proto bytes as Uint8Array

      Example

      const tx = new Transaction(txData)
      const bytes = tx.toBytes()
      // bytes: Uint8Array [10, 32, 65, ...]
      // Use for signing or network transmission

    toHex

    • toHex(): string

      Get proto bytes as hex string Useful for broadcasting to node via HTTP or storing in databases

      Returns string

      Hex encoded proto bytes (without 0x prefix)

      Example

      const tx = new Transaction(txData)
      await tx.sign(privateKey)
      const hex = tx.toHex()
      // hex: "0a20418f2b3c..."

      // Broadcast to network
      const hash = await provider.sendRawTransaction(hex)

    toJSON

    Staticcreate

    • create(properties?: ITransaction): Transaction

      Creates a new Transaction instance using the specified properties.

      Parameters

      • Optionalproperties: ITransaction

        Properties to set

      Returns Transaction

      Transaction instance

    Staticdecode

    • decode(
          reader: Uint8Array<ArrayBufferLike> | Reader,
          length?: number,
      ): Transaction

      Decodes a Transaction message from the specified reader or buffer.

      Parameters

      • reader: Uint8Array<ArrayBufferLike> | Reader

        Reader or buffer to decode from

      • Optionallength: number

        Message length if known beforehand

      Returns Transaction

      Transaction

      Throws

      If the payload is not a reader or valid buffer

      Throws

      If required fields are missing

    StaticdecodeDelimited

    • decodeDelimited(reader: Uint8Array<ArrayBufferLike> | Reader): Transaction

      Decodes a Transaction message from the specified reader or buffer, length delimited.

      Parameters

      • reader: Uint8Array<ArrayBufferLike> | Reader

        Reader or buffer to decode from

      Returns Transaction

      Transaction

      Throws

      If the payload is not a reader or valid buffer

      Throws

      If required fields are missing

    Staticencode

    • encode(message: ITransaction, writer?: Writer): Writer

      Encodes the specified Transaction message. Does not implicitly verify messages.

      Parameters

      • message: ITransaction

        Transaction message or plain object to encode

      • Optionalwriter: Writer

        Writer to encode to

      Returns Writer

      Writer

    StaticencodeDelimited

    • encodeDelimited(message: ITransaction, writer?: Writer): Writer

      Encodes the specified Transaction message, length delimited. Does not implicitly verify messages.

      Parameters

      • message: ITransaction

        Transaction message or plain object to encode

      • Optionalwriter: Writer

        Writer to encode to

      Returns Writer

      Writer

    StaticfromBytes

    • fromBytes(bytes: Uint8Array): Transaction

      Create a Transaction from raw proto bytes Decodes protobuf bytes back into a Transaction object

      Parameters

      • bytes: Uint8Array

        Proto-encoded transaction bytes

      Returns Transaction

      Transaction instance

      Example

      // Decode bytes from storage or network
      const bytes = new Uint8Array([10, 32, 65, ...])
      const tx = Transaction.fromBytes(bytes)

      // Verify and use
      console.log(tx.getHash())
      console.log(tx.isSigned())

    StaticfromHex

    • fromHex(hex: string): Transaction

      Create a Transaction from hex-encoded proto bytes Decodes a hex string back into a Transaction object

      Parameters

      • hex: string

        Hex string of proto-encoded transaction (with or without 0x prefix)

      Returns Transaction

      Transaction instance

      Example

      // Decode hex string from storage or API
      const hex = "0a20418f2b3c..."
      const tx = Transaction.fromHex(hex)

      // Verify signature
      console.log(tx.isSigned()) // true or false

      // Get transaction hash
      console.log(tx.getHash())

    StaticfromObject

    • fromObject(obj: { [k: string]: unknown }): Transaction

      Create a Transaction from a plain JSON object (from API) Properly converts base64 strings to Uint8Array for proto fields. This is typically used when receiving transaction data from the node's API.

      Parameters

      • obj: { [k: string]: unknown }

        Plain object with base64-encoded byte fields

      Returns Transaction

      Transaction instance

      Example

      // Response from node's /transaction/build endpoint
      const response = await fetch('/transaction/build', {
        method: 'POST',
        body: JSON.stringify(buildRequest)
      })
      const data = await response.json()

      // Convert API response to Transaction
      const tx = Transaction.fromObject(data.result)

      // Sign and broadcast
      await tx.sign(privateKey)
      await provider.sendRawTransaction(tx.toHex())

    StaticfromTransaction

    • fromTransaction(tx: Transaction): Transaction

      Create a new Transaction from an existing Transaction Creates a deep copy of the transaction

      Parameters

      Returns Transaction

      New Transaction instance

      Example

      const originalTx = new Transaction(txData)
      const copiedTx = Transaction.fromTransaction(originalTx)

      // Modifications to copiedTx won't affect originalTx
      await copiedTx.sign(privateKey)

    StaticgetTypeUrl

    StatictoObject

    • toObject(
          message: Transaction,
          options?: IConversionOptions,
      ): { [k: string]: any }

      Creates a plain object from a Transaction message. Also converts values to other types if specified.

      Parameters

      • message: Transaction

        Transaction

      • Optionaloptions: IConversionOptions

        Conversion options

      Returns { [k: string]: any }

      Plain object

    Staticverify

    • verify(message: { [k: string]: any }): null | string

      Verifies a Transaction message.

      Parameters

      • message: { [k: string]: any }

        Plain object to verify

      Returns null | string

      null if valid, otherwise the reason why it is not

    Settings

    Member Visibility

    On This Page

    Constructors
    Properties
    Methods