ExecuteTransaction gRPC Method

Parameters

transaction_data

object

REQUIRED

The transaction data to execute

signatures

array

REQUIRED

Array of signatures for the transaction

options

object

Execution options including request type

Returns

finality

oneof

Indicates the finality state of the executed transaction. Only one of the following fields will be set.

transaction

object

Transaction data corresponding to the requested transaction digest

digest

string

The digest of this Transaction

transaction

object

The transaction itself containing sender, gas payment, and execution details

signatures

array

List of user signatures that authorized the execution of this transaction

effects

object

The effects produced by this transaction including execution status, gas used, and changed objects

events

object

The events emitted during execution of this transaction (if any)

checkpoint

integer

The sequence number for the checkpoint that includes this transaction

timestamp

object

The Unix timestamp of the checkpoint that includes this transaction

balance_changes

array

List of balance changes caused by this transaction

input_objects

array

Set of input objects used during the execution of this transaction

output_objects

array

Set of output objects produced from the execution of this transaction

Request

grpcurl -proto ./sui/rpc/v2beta/transaction_execution_service.proto -H "x-token: YOUR_TOKEN_VALUE"
-d '{
    "transaction": {
      "bcs": {
        "value": "BASE64_ENCODED_TX"
      }
    },
    "options": {
      "show_input": true,
      "show_effects": true,
      "show_events": true,
      "show_object_changes": true,
      "show_balance_changes": true
  }
}' docs-demo.sui-mainnet.quiknode.pro:9000 sui.rpc.v2beta.TransactionExecutionService/ExecuteTransaction

package main

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

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

	pb "sui-grpc/sui/proto/generated/sui/rpc/v2beta"  // 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"
)

// x-token Auth implementation
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() {
	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.NewTransactionExecutionServiceClient(conn)

	bcsTx := []byte("YOUR_BCS_SERIALIZED_TX_BYTES")

	sig := &pb.UserSignature{
		Scheme:    pb.SignatureScheme_ED25519,
		Signature: []byte("YOUR_SIGNATURE_BYTES"),
		PublicKey: []byte("YOUR_PUBLIC_KEY_BYTES"),
	}

	// ReadMask specifies what response fields to return
	readMask := &fieldmaskpb.FieldMask{
		Paths: []string{"transaction", "finality"},
	}

	// Build request
	req := &pb.ExecuteTransactionRequest{
		Transaction: &pb.Transaction{
			Bcs: &pb.Bcs{
				Bytes: bcsTx,
			},
		},
		Signatures: []*pb.UserSignature{sig},
		ReadMask:   readMask,
	}

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

	// Optional: metadata if not using grpc.PerRPCCredentials
	ctx = metadata.AppendToOutgoingContext(ctx, "x-token", token)

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

	// Marshal response to 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)
	}

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

import * as grpc from '@grpc/grpc-js';
import * as protoLoader from '@grpc/proto-loader';
import * as path from '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

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

// Load proto
const PROTO_PATH = path.join(__dirname, 'protos/sui/rpc/v2beta/transaction_execution_service.proto');
const COMMON_INCLUDE = path.join(__dirname, 'protos');

const packageDefinition = protoLoader.loadSync(PROTO_PATH, {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true,
  includeDirs: [COMMON_INCLUDE],
});

const proto = grpc.loadPackageDefinition(packageDefinition) as any;
const TransactionExecutionService = proto.sui.rpc.v2beta.TransactionExecutionService;

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

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

// Placeholder request
const request = {
  transaction: {
    bcs: {
      bytes: Buffer.from('YOUR_BCS_SERIALIZED_TX_BYTES', 'base64') // Replace with actual bytes
    }
  },
  signatures: [
    {
      scheme: 0, // Usually 0 = ED25519
      signature: Buffer.from('YOUR_SIGNATURE_BYTES', 'base64'), // Replace with actual bytes
      public_key: Buffer.from('YOUR_PUBLIC_KEY_BYTES', 'base64') // Replace with actual bytes
    }
  ],
  read_mask: {
    paths: ['transaction', 'finality']
  }
};

// Call ExecuteTransaction
client.ExecuteTransaction(request, metadata, (err: grpc.ServiceError | null, response: any) => {
  if (err) {
    console.error('gRPC Error:', err.message);
    console.error('Details:', err.details);
  } else {
    console.log('Response:', 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.v2beta import (
    transaction_execution_service_pb2,
    transaction_execution_service_pb2_grpc,
    transaction_pb2,
    signature_pb2,
    bcs_pb2
)

# 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 = 'YOUR_TOKEN_HERE';

def execute_transaction():
    channel = grpc.secure_channel(endpoint, grpc.ssl_channel_credentials())
    stub = transaction_execution_service_pb2_grpc.TransactionExecutionServiceStub(channel)

    # === PLACEHOLDER: BCS-serialized transaction ===
    transaction = transaction_pb2.Transaction(
        bcs=bcs_pb2.Bcs(
            bytes=b"YOUR_BCS_SERIALIZED_TX_BYTES"
        )
    )

    signature = signature_pb2.UserSignature(
        scheme=0,  # e.g., 0 = ED25519
        signature=b"YOUR_SIGNATURE_BYTES",
        public_key=b"YOUR_PUBLIC_KEY_BYTES"
    )

    read_mask = FieldMask(paths=["transaction", "finality"])

    request = transaction_execution_service_pb2.ExecuteTransactionRequest(
        transaction=transaction,
        signatures=[signature],
        read_mask=read_mask
    )

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

    try:
        response = stub.ExecuteTransaction(request, metadata=metadata)
        return MessageToDict(response, preserving_proto_field_name=True)
    except grpc.RpcError as e:
        return {
            "error": e.code().name,
            "details": e.details()
        }


def main():
    result = execute_transaction()
    print(json.dumps(result, indent=2))


if __name__ == "__main__":
    main()

Don't have an account yet?

Create your QuickNode endpoint in seconds and start building

Get started for free