BatchGetTransactions gRPC Method

Parameters

digests

array

REQUIRED

read_mask

object

paths

array

Returns

transactions

array

digest

string

transaction

object

bcs

object

name

string

value

string

digest

string

version

integer

kind

object

programmableTransaction

object

inputs

array

kind

string

objectId

string

mutable

boolean

pure

string

version

string

digest

string

commands

array

moveCall

object

package

string

module

string

function

string

typeArguments

array

arguments

array

kind

string

input

integer

result

integer

sender

string

gasPayment

object

objects

array

objectId

string

version

string

digest

string

owner

string

price

string

budget

string

expiration

object

kind

string

effects

object

bcs

object

name

string

value

string

digest

string

version

integer

status

object

success

boolean

epoch

string

gasUsed

object

computationCost

string

storageCost

string

storageRebate

string

nonRefundableStorageFee

string

transactionDigest

string

gasObject

object

objectId

string

inputState

string

inputVersion

string

inputDigest

string

inputOwner

object

kind

string

address

string

outputState

string

outputVersion

string

outputDigest

string

outputOwner

object

kind

string

address

string

idOperation

string

eventsDigest

string

dependencies

array

lamportVersion

string

changedObjects

array

objectId

string

inputState

string

inputVersion

string

inputDigest

string

inputOwner

object

kind

string

address

string

outputState

string

outputVersion

string

outputDigest

string

outputOwner

object

kind

string

address

string

idOperation

string

objectType

string

unchangedConsensusObjects

array

kind

string

objectId

string

version

string

digest

string

events

object

bcs

object

name

string

value

string

digest

string

events

array

packageId

string

module

string

sender

string

eventType

string

contents

object

name

string

value

string

json

object

balanceManagerId

string

baseAssetQuantityCanceled

string

clientOrderId

string

isBid

boolean

orderId

string

originalQuantity

string

poolId

string

price

string

timestamp

string

trader

string

Request

grpcurl \
  -import-path . \
  -proto sui/rpc/v2beta2/ledger_service.proto \
  -H "x-token: YOUR_TOKEN_VALUE" \
  -d '{
    "digests": [
      "HjuLoCGjS4wBC5KfqmExUa7GcF3yzaWRN1YoYpgxQC6G"
    ],
    "read_mask": {
      "paths": [
        "digest",
        "transaction",
        "effects",
        "events"
      ]
    }
  }' \
  docs-demo.sui-mainnet.quiknode.pro:9000 \
  sui.rpc.v2beta2.LedgerService/BatchGetTransactions

package main

import (
	"context"
	"crypto/tls"
	"encoding/json"
	"fmt"
	"log"
	"time"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"google.golang.org/protobuf/encoding/protojson"
	"google.golang.org/protobuf/types/known/fieldmaskpb"

	pb "sui-grpc/sui/rpc/v2beta2" // Your Generated .pb.go files path
)

// QuickNode endpoints consist of two crucial components: the endpoint name and the corresponding token
// For eg: QN Endpoint: https://docs-demo.sui-mainnet.quiknode.pro/abcde123456789
// endpoint will be: docs-demo.sui-mainnet.quiknode.pro:9000  {9000 is the port number for Sui gRPC}
// token will be : abcde123456789

var (
	token    = "YOUR_TOKEN_NUMBER"
	endpoint = "YOUR_QN_ENDPOINT:9000"
)

// Auth structure for x-token
type auth struct {
	token string
}

func (a *auth) GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error) {
	return map[string]string{
		"x-token": a.token,
	}, nil
}

func (a *auth) RequireTransportSecurity() bool {
	return true
}

func main() {
	// TLS credentials and x-token auth
	creds := credentials.NewTLS(&tls.Config{})
	opts := []grpc.DialOption{
		grpc.WithTransportCredentials(creds),
		grpc.WithPerRPCCredentials(&auth{token}),
	}

	conn, err := grpc.Dial(endpoint, opts...)
	if err != nil {
		log.Fatalf("Failed to connect: %v", err)
	}
	defer conn.Close()

	client := pb.NewLedgerServiceClient(conn)

	// Digest array
	digests := []string{
		"HjuLoCGjS4wBC5KfqmExUa7GcF3yzaWRN1YoYpgxQC6G",
	}

	// FieldMask to restrict returned fields
	readMask := &fieldmaskpb.FieldMask{
		Paths: []string{"digest", "transaction", "effects", "events"},
	}

	req := &pb.BatchGetTransactionsRequest{
		Digests:  digests,
		ReadMask: readMask,
	}

	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	resp, err := client.BatchGetTransactions(ctx, req)
	if err != nil {
		log.Fatalf("BatchGetTransactions failed: %v", err)
	}

	// Format response as pretty JSON
	marshaler := protojson.MarshalOptions{
		UseProtoNames:   true,
		EmitUnpopulated: true,
		Indent:          "  ",
	}

	jsonBytes, err := marshaler.Marshal(resp)
	if err != nil {
		log.Fatalf("Failed to marshal response: %v", err)
	}

	var pretty map[string]interface{}
	if err := json.Unmarshal(jsonBytes, &pretty); err != nil {
		log.Fatalf("Failed to parse JSON: %v", err)
	}

	formatted, _ := json.MarshalIndent(pretty, "", "  ")
	fmt.Println(string(formatted))
}

import * as grpc from '@grpc/grpc-js';
import * as protoLoader from '@grpc/proto-loader';
import * as path from 'path';

const PROTO_PATH = path.join(__dirname, 'protos/proto/sui/rpc/v2beta2/ledger_service.proto');

// QuickNode endpoints consist of two crucial components: the endpoint name and the corresponding token
// For eg: QN Endpoint: https://docs-demo.sui-mainnet.quiknode.pro/abcde123456789
// endpoint will be: docs-demo.sui-mainnet.quiknode.pro:9000  {9000 is the port number for Sui gRPC}
// token will be : abcde123456789

const endpoint = 'docs-demo.sui-mainnet.quiknode.pro:9000';
const token = 'abcde123456789';

// Load proto definition
const packageDefinition = protoLoader.loadSync(PROTO_PATH, {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true,
  includeDirs: [path.join(__dirname, 'protos/proto')],
});
const proto = grpc.loadPackageDefinition(packageDefinition) as any;
const LedgerService = proto.sui.rpc.v2beta2.LedgerService;

// Create gRPC client with TLS
const client = new LedgerService(endpoint, grpc.credentials.createSsl());

// Metadata for authentication
const metadata = new grpc.Metadata();
metadata.add('x-token', token);

// Request setup
const request = {
  digests: ['HjuLoCGjS4wBC5KfqmExUa7GcF3yzaWRN1YoYpgxQC6G'], // Replace with valid digests
  read_mask: {
    paths: ['digest', 'transaction', 'effects', 'events'], // FieldMask
  },
};

// Invoke BatchGetTransactions
client.BatchGetTransactions(request, metadata, (err: grpc.ServiceError | null, response: any) => {
  if (err) {
    console.error('gRPC Error:', {
      code: err.code,
      message: err.message,
      details: err.details,
    });
  } else {
    console.log('BatchGetTransactions Response:');
    console.log(JSON.stringify(response, null, 2));
  }
});

import grpc
import json
from google.protobuf.field_mask_pb2 import FieldMask
from google.protobuf.json_format import MessageToDict
from sui.rpc.v2beta2 import ledger_service_pb2, ledger_service_pb2_grpc


def get_batch_transactions():
    # QuickNode endpoints consist of two crucial components: the endpoint name and the corresponding token
    # For eg: QN Endpoint: https://docs-demo.sui-mainnet.quiknode.pro/abcde123456789
    # endpoint will be: docs-demo.sui-mainnet.quiknode.pro:9000  {9000 is the port number for Sui gRPC}
    # token will be: abcde123456789

    endpoint = 'docs-demo.sui-mainnet.quiknode.pro:9000';
    token = 'abcde123456789';

    channel = grpc.secure_channel(endpoint, grpc.ssl_channel_credentials())
    stub = ledger_service_pb2_grpc.LedgerServiceStub(channel)

    tx_digests = [
        "HjuLoCGjS4wBC5KfqmExUa7GcF3yzaWRN1YoYpgxQC6G"
    ]

    read_mask = FieldMask(paths=[
        "digest",
        "transaction",
        "effects",
        "events"
    ])

    request = ledger_service_pb2.BatchGetTransactionsRequest(
        digests=tx_digests,
        read_mask=read_mask
    )

    metadata = [("x-token", token)]

    return stub.BatchGetTransactions(request, metadata=metadata)


def parse_response_to_json(response):
    return json.dumps(
        MessageToDict(response, preserving_proto_field_name=True),
        indent=2
    )


def main():
    try:
        response = get_batch_transactions()
        print(parse_response_to_json(response))
    except grpc.RpcError as e:
        print(f"{e.code().name}: {e.details()}")


if __name__ == "__main__":
    main()

Don't have an account yet?

Create your QuickNode endpoint in seconds and start building

Get started for free

BatchGetTransactions gRPC Method

Loading...

Parameters

Returns