Parameters

chain_id

integer

The numeric Web3 chain ID used in the EIP-712 signing domain; use 1 for Injective Mainnet.

tx

string

The Amino-encoded transaction JSON bytes, excluding the separately supplied protobuf messages and base64-encoded in JSON representations.

msgs

array

The Cosmos message JSON documents included in the transaction, each UTF-8 encoded and represented as base64 in JSON requests.

pub_key

object

The type and bytes of the signer’s ethsecp256k1 public key.

type

string

The protobuf type URL identifying the signer’s public-key format.

key

string

The hex-encoded ethsecp256k1 public-key bytes.

signature

string

The hex-encoded ethsecp256k1 signature produced by the transaction sender.

fee_payer

string

The Injective address of the account paying the transaction fee.

fee_payer_sig

string

The hex-encoded ethsecp256k1 signature produced by the fee payer.

mode

string

The transaction broadcast mode that controls when the request returns.

Returns

tx_hash

string

The Tendermint transaction hash encoded as a hexadecimal string.

height

string

The height of the returned Injective block.

index

integer

The zero-based position of the transaction within its block.

codespace

string

The module namespace that produced the transaction result code.

code

integer

The numeric transaction result code; zero indicates successful execution.

data

string

The result bytes returned by transaction execution, base64-encoded in JSON representations.

raw_log

string

The raw application log produced while executing the transaction.

timestamp

string

The UTC timestamp of the block immediately preceding transaction inclusion.

Request

1
package main
2

3
import (
4
	"context"
5
	"crypto/tls"
6
	"fmt"
7
	"log"
8
	"time"
9

10
	"google.golang.org/grpc"
11
	"google.golang.org/grpc/credentials"
12
	"google.golang.org/grpc/metadata"
13
	"google.golang.org/protobuf/encoding/protojson"
14

15
	pb "injective-indexer-grpc/pb/exchange"
16
)
17

18
const grpcEndpoint = "YOUR_ENDPOINT_NAME.injective-mainnet.quiknode.pro:443"
19
const authToken = "YOUR_TOKEN"
20

21
func main() {
22
	creds := credentials.NewTLS(&tls.Config{MinVersion: tls.VersionTLS12})
23
	conn, err := grpc.Dial(grpcEndpoint, grpc.WithTransportCredentials(creds))
24
	if err != nil {
25
		log.Fatal(err)
26
	}
27
	defer conn.Close()
28

29
	ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
30
	defer cancel()
31
	ctx = metadata.AppendToOutgoingContext(ctx, "x-token", authToken)
32

33
	client := pb.NewInjectiveExchangeRPCClient(conn)
34
	// WARNING: This method can change Mainnet state. The sample values are intentionally invalid.
35
	request := &pb.BroadcastTxRequest{}
36
	requestJSON := `{"chain_id":"1","tx":"AQ==","msgs":["AQ=="],"pub_key":{"type":"/injective.crypto.v1beta1.ethsecp256k1.PubKey","key":"020000000000000000000000000000000000000000000000000000000000000000"},"signature":"00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","mode":"sync"}`
37
	if err := protojson.Unmarshal([]byte(requestJSON), request); err != nil {
38
		log.Fatal(err)
39
	}
40

41
	response, err := client.BroadcastTx(ctx, request)
42
	if err != nil {
43
		log.Fatal(err)
44
	}
45

46
	data, err := protojson.MarshalOptions{UseProtoNames: true, Indent: "  "}.Marshal(response)
47
	if err != nil {
48
		log.Fatal(err)
49
	}
50
	data = append(data, '\n')
51
	fmt.Print(string(data))
52
}
53

1
package main
2

3
import (
4
	"context"
5
	"crypto/tls"
6
	"fmt"
7
	"log"
8
	"time"
9

10
	"google.golang.org/grpc"
11
	"google.golang.org/grpc/credentials"
12
	"google.golang.org/grpc/metadata"
13
	"google.golang.org/protobuf/encoding/protojson"
14

15
	pb "injective-indexer-grpc/pb/exchange"
16
)
17

18
const grpcEndpoint = "YOUR_ENDPOINT_NAME.injective-mainnet.quiknode.pro:443"
19
const authToken = "YOUR_TOKEN"
20

21
func main() {
22
	creds := credentials.NewTLS(&tls.Config{MinVersion: tls.VersionTLS12})
23
	conn, err := grpc.Dial(grpcEndpoint, grpc.WithTransportCredentials(creds))
24
	if err != nil {
25
		log.Fatal(err)
26
	}
27
	defer conn.Close()
28

29
	ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
30
	defer cancel()
31
	ctx = metadata.AppendToOutgoingContext(ctx, "x-token", authToken)
32

33
	client := pb.NewInjectiveExchangeRPCClient(conn)
34
	// WARNING: This method can change Mainnet state. The sample values are intentionally invalid.
35
	request := &pb.BroadcastTxRequest{}
36
	requestJSON := `{"chain_id":"1","tx":"AQ==","msgs":["AQ=="],"pub_key":{"type":"/injective.crypto.v1beta1.ethsecp256k1.PubKey","key":"020000000000000000000000000000000000000000000000000000000000000000"},"signature":"00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","mode":"sync"}`
37
	if err := protojson.Unmarshal([]byte(requestJSON), request); err != nil {
38
		log.Fatal(err)
39
	}
40

41
	response, err := client.BroadcastTx(ctx, request)
42
	if err != nil {
43
		log.Fatal(err)
44
	}
45

46
	data, err := protojson.MarshalOptions{UseProtoNames: true, Indent: "  "}.Marshal(response)
47
	if err != nil {
48
		log.Fatal(err)
49
	}
50
	data = append(data, '\n')
51
	fmt.Print(string(data))
52
}
53

1
const grpc = require('@grpc/grpc-js')
2
const protoLoader = require('@grpc/proto-loader')
3
const path = require('path')
4

5
const GRPC_ENDPOINT = 'YOUR_ENDPOINT_NAME.injective-mainnet.quiknode.pro:443'
6
const AUTH_TOKEN = 'YOUR_TOKEN'
7

8
const definition = protoLoader.loadSync(
9
	path.join(__dirname, 'proto/exchange/injective_exchange_rpc.proto'),
10
	{
11
		keepCase: true,
12
		longs: String,
13
		enums: String,
14
		bytes: String,
15
		defaults: true,
16
		oneofs: true,
17
	}
18
)
19

20
const proto = grpc.loadPackageDefinition(definition).injective_exchange_rpc
21
const client = new proto.InjectiveExchangeRPC(
22
	GRPC_ENDPOINT,
23
	grpc.credentials.createSsl()
24
)
25

26
const metadata = new grpc.Metadata()
27
metadata.add('x-token', AUTH_TOKEN)
28

29
// WARNING: This method can change Mainnet state. The sample values are intentionally invalid.
30
const request = {
31
	chain_id: '1',
32
	tx: 'AQ==',
33
	msgs: ['AQ=='],
34
	pub_key: {
35
		type: '/injective.crypto.v1beta1.ethsecp256k1.PubKey',
36
		key: '020000000000000000000000000000000000000000000000000000000000000000',
37
	},
38
	signature:
39
		'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
40
	mode: 'sync',
41
}
42

43
client.BroadcastTx(
44
	request,
45
	metadata,
46
	{ deadline: Date.now() + 20000 },
47
	(error, response) => {
48
		if (error) {
49
			console.error(error)
50
			process.exitCode = 1
51
			return
52
		}
53

54
		console.log(JSON.stringify(response, null, 2))
55
		client.close()
56
	}
57
)
58

1
const grpc = require('@grpc/grpc-js')
2
const protoLoader = require('@grpc/proto-loader')
3
const path = require('path')
4

5
const GRPC_ENDPOINT = 'YOUR_ENDPOINT_NAME.injective-mainnet.quiknode.pro:443'
6
const AUTH_TOKEN = 'YOUR_TOKEN'
7

8
const definition = protoLoader.loadSync(
9
	path.join(__dirname, 'proto/exchange/injective_exchange_rpc.proto'),
10
	{
11
		keepCase: true,
12
		longs: String,
13
		enums: String,
14
		bytes: String,
15
		defaults: true,
16
		oneofs: true,
17
	}
18
)
19

20
const proto = grpc.loadPackageDefinition(definition).injective_exchange_rpc
21
const client = new proto.InjectiveExchangeRPC(
22
	GRPC_ENDPOINT,
23
	grpc.credentials.createSsl()
24
)
25

26
const metadata = new grpc.Metadata()
27
metadata.add('x-token', AUTH_TOKEN)
28

29
// WARNING: This method can change Mainnet state. The sample values are intentionally invalid.
30
const request = {
31
	chain_id: '1',
32
	tx: 'AQ==',
33
	msgs: ['AQ=='],
34
	pub_key: {
35
		type: '/injective.crypto.v1beta1.ethsecp256k1.PubKey',
36
		key: '020000000000000000000000000000000000000000000000000000000000000000',
37
	},
38
	signature:
39
		'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
40
	mode: 'sync',
41
}
42

43
client.BroadcastTx(
44
	request,
45
	metadata,
46
	{ deadline: Date.now() + 20000 },
47
	(error, response) => {
48
		if (error) {
49
			console.error(error)
50
			process.exitCode = 1
51
			return
52
		}
53

54
		console.log(JSON.stringify(response, null, 2))
55
		client.close()
56
	}
57
)
58

1
import json
2
import grpc
3
from google.protobuf.json_format import MessageToJson, ParseDict
4
from exchange import injective_exchange_rpc_pb2
5
from exchange import injective_exchange_rpc_pb2_grpc
6

7
GRPC_ENDPOINT = "YOUR_ENDPOINT_NAME.injective-mainnet.quiknode.pro:443"
8
AUTH_TOKEN = "YOUR_TOKEN"
9

10
channel = grpc.secure_channel(GRPC_ENDPOINT, grpc.ssl_channel_credentials())
11
client = injective_exchange_rpc_pb2_grpc.InjectiveExchangeRPCStub(channel)
12
metadata = (("x-token", AUTH_TOKEN),)
13

14
# WARNING: This method can change Mainnet state. The sample values are intentionally invalid.
15
request_data = {
16
  "chain_id": "1",
17
  "tx": "AQ==",
18
  "msgs": [
19
    "AQ=="
20
  ],
21
  "pub_key": {
22
    "type": "/injective.crypto.v1beta1.ethsecp256k1.PubKey",
23
    "key": "020000000000000000000000000000000000000000000000000000000000000000"
24
  },
25
  "signature": "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
26
  "mode": "sync"
27
}
28
request = ParseDict(request_data, injective_exchange_rpc_pb2.BroadcastTxRequest())
29

30
try:
31
    response = client.BroadcastTx(request, metadata=metadata, timeout=20)
32
    print(MessageToJson(response, preserving_proto_field_name=True, indent=2))
33
except grpc.RpcError as error:
34
    print(f"gRPC error {error.code().name}: {error.details()}")
35
    raise
36
finally:
37
    channel.close()
38

1
import json
2
import grpc
3
from google.protobuf.json_format import MessageToJson, ParseDict
4
from exchange import injective_exchange_rpc_pb2
5
from exchange import injective_exchange_rpc_pb2_grpc
6

7
GRPC_ENDPOINT = "YOUR_ENDPOINT_NAME.injective-mainnet.quiknode.pro:443"
8
AUTH_TOKEN = "YOUR_TOKEN"
9

10
channel = grpc.secure_channel(GRPC_ENDPOINT, grpc.ssl_channel_credentials())
11
client = injective_exchange_rpc_pb2_grpc.InjectiveExchangeRPCStub(channel)
12
metadata = (("x-token", AUTH_TOKEN),)
13

14
# WARNING: This method can change Mainnet state. The sample values are intentionally invalid.
15
request_data = {
16
  "chain_id": "1",
17
  "tx": "AQ==",
18
  "msgs": [
19
    "AQ=="
20
  ],
21
  "pub_key": {
22
    "type": "/injective.crypto.v1beta1.ethsecp256k1.PubKey",
23
    "key": "020000000000000000000000000000000000000000000000000000000000000000"
24
  },
25
  "signature": "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
26
  "mode": "sync"
27
}
28
request = ParseDict(request_data, injective_exchange_rpc_pb2.BroadcastTxRequest())
29

30
try:
31
    response = client.BroadcastTx(request, metadata=metadata, timeout=20)
32
    print(MessageToJson(response, preserving_proto_field_name=True, indent=2))
33
except grpc.RpcError as error:
34
    print(f"gRPC error {error.code().name}: {error.details()}")
35
    raise
36
finally:
37
    channel.close()
38

Don't have an account yet?

Create your Quicknode endpoint in seconds and start building

Get started for free