GoldRush

https://goldrush.dev/docs/
Admin
GoldRush offers a comprehensive Blockchain Data API suite, including Foundational (historical) and...
Tokens:538,727
Snippets:3,653
Trust Score:8.9
Update:2 months ago
Show doc for...
Tokens:
Raw
### Request Examples

Source: https://goldrush.dev/docs/api-reference/json-rpc/solana/getconfirmedsignaturesforaddress2

Examples of how to call the method using curl, @solana/kit, and Python.

```bash
curl https://rpc.goldrushdata.com/v1/solana-mainnet \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getConfirmedSignaturesForAddress2",
    "params": ["9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM", {"limit":10}]
  }'
```

```typescript
import {
  createDefaultRpcTransport,
  createSolanaRpcFromTransport,
} from "@solana/kit";

const transport = createDefaultRpcTransport({
  url: "https://rpc.goldrushdata.com/v1/solana-mainnet",
  headers: { Authorization: `Bearer ${process.env.GOLDRUSH_API_KEY}` },
});
const rpc = createSolanaRpcFromTransport(transport);

const result = await rpc.getConfirmedSignaturesForAddress2("9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM", {"limit":10}).send();
console.log(result);
```

```python
import os
import requests

resp = requests.post(
    "https://rpc.goldrushdata.com/v1/solana-mainnet",
    headers={
        "Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}",
        "Content-Type": "application/json",
    },
    json={"jsonrpc": "2.0", "id": 1, "method": "getConfirmedSignaturesForAddress2", "params": ["9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM", {"limit":10}]},
)
print(resp.json()["result"])
```

--------------------------------

### logsSubscribe Examples

Source: https://goldrush.dev/docs/api-reference/json-rpc/solana/logssubscribe

Examples of how to initiate a logs subscription using wscat and the @solana/kit library.

```bash
# Connect (header auth works from Node/CLI clients):
wscat -c "wss://rpc.goldrushdata.com/v1/solana-mainnet" \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY"

# Once connected, send:
{"jsonrpc":"2.0","id":1,"method":"logsSubscribe","params":[{"mentions":["11111111111111111111111111111111"]}, {"commitment":"finalized"}]}
```

```typescript
import { createSolanaRpcSubscriptions } from "@solana/kit";

// Authenticate with the Authorization: Bearer header on the WS handshake.
// See /goldrush-json-rpc/authentication.
const rpcSubscriptions = createSolanaRpcSubscriptions("wss://rpc.goldrushdata.com/v1/solana-mainnet");

const abortController = new AbortController();
const notifications = await rpcSubscriptions
  .logsSubscribe({"mentions":["11111111111111111111111111111111"]}, {"commitment":"finalized"})
  .subscribe({ abortSignal: abortController.signal });

for await (const notification of notifications) {
  console.log(notification);
}
```

--------------------------------

### eth_syncing Implementation Examples

Source: https://goldrush.dev/docs/api-reference/json-rpc/bsc/eth-syncing

Examples of how to call eth_syncing using various tools and libraries.

```bash
curl https://rpc.goldrushdata.com/v1/bsc-mainnet \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_syncing",
    "params": []
  }'
```

```javascript
import { ethers } from "ethers";

const url = "https://rpc.goldrushdata.com/v1/bsc-mainnet";
const fetchReq = new ethers.FetchRequest(url);
fetchReq.setHeader("Authorization", `Bearer ${process.env.GOLDRUSH_API_KEY}`);

const provider = new ethers.JsonRpcProvider(fetchReq);
const result = await provider.send("eth_syncing", []);
console.log(result);
```

```javascript
import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://rpc.goldrushdata.com/v1/bsc-mainnet", {
    fetchOptions: {
      headers: {
        Authorization: `Bearer ${process.env.GOLDRUSH_API_KEY}`,
      },
    },
  }),
});

const result = await client.request({
  method: "eth_syncing",
  params: [],
});
console.log(result);
```

```javascript
import { Web3 } from "web3";

const provider = new Web3.providers.HttpProvider(
  "https://rpc.goldrushdata.com/v1/bsc-mainnet",
  {
    headers: [
      { name: "Authorization", value: `Bearer ${process.env.GOLDRUSH_API_KEY}` },
    ],
  }
);
const web3 = new Web3(provider);

const result = await web3.currentProvider.request({
  method: "eth_syncing",
  params: [],
});
console.log(result);
```

```python
from os import environ
from web3 import Web3

w3 = Web3(Web3.HTTPProvider(
    "https://rpc.goldrushdata.com/v1/bsc-mainnet",
    request_kwargs={
        "headers": {
            "Authorization": f"Bearer {environ['GOLDRUSH_API_KEY']}",
        },
    },
))
result = w3.manager.request_blocking("eth_syncing", [])
print(result)
```

--------------------------------

### getTokenSupply Examples

Source: https://goldrush.dev/docs/api-reference/json-rpc/solana/gettokensupply

Examples for calling getTokenSupply using cURL, @solana/kit, and Python.

```bash
curl https://rpc.goldrushdata.com/v1/solana-mainnet \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getTokenSupply",
    "params": ["EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", {"commitment":"finalized"}]
  }'
```

```typescript
import {
  createDefaultRpcTransport,
  createSolanaRpcFromTransport,
} from "@solana/kit";

const transport = createDefaultRpcTransport({
  url: "https://rpc.goldrushdata.com/v1/solana-mainnet",
  headers: { Authorization: `Bearer ${process.env.GOLDRUSH_API_KEY}` },
});
const rpc = createSolanaRpcFromTransport(transport);

const result = await rpc.getTokenSupply("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", {"commitment":"finalized"}).send();
console.log(result);
```

```python
import os
import requests

resp = requests.post(
    "https://rpc.goldrushdata.com/v1/solana-mainnet",
    headers={
        "Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}",
        "Content-Type": "application/json",
    },
    json={"jsonrpc": "2.0", "id": 1, "method": "getTokenSupply", "params": ["EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", {"commitment":"finalized"}]},
)
print(resp.json()["result"])
```

--------------------------------

### web3_clientVersion Implementation Examples

Source: https://goldrush.dev/docs/api-reference/json-rpc/arbitrum/web3-clientversion

Examples of how to call web3_clientVersion using various tools and libraries.

```bash
curl https://rpc.goldrushdata.com/v1/arbitrum-mainnet \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "web3_clientVersion",
    "params": []
  }'
```

```javascript
import { ethers } from "ethers";

const url = "https://rpc.goldrushdata.com/v1/arbitrum-mainnet";
const fetchReq = new ethers.FetchRequest(url);
fetchReq.setHeader("Authorization", `Bearer ${process.env.GOLDRUSH_API_KEY}`);

const provider = new ethers.JsonRpcProvider(fetchReq);
const result = await provider.send("web3_clientVersion", []);
console.log(result);
```

```javascript
import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://rpc.goldrushdata.com/v1/arbitrum-mainnet", {
    fetchOptions: {
      headers: {
        Authorization: `Bearer ${process.env.GOLDRUSH_API_KEY}`,
      },
    },
  }),
});

const result = await client.request({
  method: "web3_clientVersion",
  params: [],
});
console.log(result);
```

```javascript
import { Web3 } from "web3";

const provider = new Web3.providers.HttpProvider(
  "https://rpc.goldrushdata.com/v1/arbitrum-mainnet",
  {
    headers: [
      { name: "Authorization", value: `Bearer ${process.env.GOLDRUSH_API_KEY}` },
    ],
  }
);
const web3 = new Web3(provider);

const result = await web3.currentProvider.request({
  method: "web3_clientVersion",
  params: [],
});
console.log(result);
```

```python
from os import environ
from web3 import Web3

w3 = Web3(Web3.HTTPProvider(
    "https://rpc.goldrushdata.com/v1/arbitrum-mainnet",
    request_kwargs={
        "headers": {
            "Authorization": f"Bearer {environ['GOLDRUSH_API_KEY']}",
        },
    },
))
result = w3.manager.request_blocking("web3_clientVersion", [])
print(result)
```

--------------------------------

### Request Examples

Source: https://goldrush.dev/docs/api-reference/json-rpc/arbitrum/eth-maxpriorityfeepergas

Examples of how to call eth_maxPriorityFeePerGas using various tools and libraries.

```bash
curl https://rpc.goldrushdata.com/v1/arbitrum-mainnet \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_maxPriorityFeePerGas",
    "params": []
  }'
```

```javascript
import { ethers } from "ethers";

const url = "https://rpc.goldrushdata.com/v1/arbitrum-mainnet";
const fetchReq = new ethers.FetchRequest(url);
fetchReq.setHeader("Authorization", `Bearer ${process.env.GOLDRUSH_API_KEY}`);

const provider = new ethers.JsonRpcProvider(fetchReq);
const result = await provider.send("eth_maxPriorityFeePerGas", []);
console.log(result);
```

```javascript
import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://rpc.goldrushdata.com/v1/arbitrum-mainnet", {
    fetchOptions: {
      headers: {
        Authorization: `Bearer ${process.env.GOLDRUSH_API_KEY}`,
      },
    },
  }),
});

const result = await client.request({
  method: "eth_maxPriorityFeePerGas",
  params: [],
});
console.log(result);
```

```javascript
import { Web3 } from "web3";

const provider = new Web3.providers.HttpProvider(
  "https://rpc.goldrushdata.com/v1/arbitrum-mainnet",
  {
    headers: [
      { name: "Authorization", value: `Bearer ${process.env.GOLDRUSH_API_KEY}` },
    ],
  }
);
const web3 = new Web3(provider);

const result = await web3.currentProvider.request({
  method: "eth_maxPriorityFeePerGas",
  params: [],
});
console.log(result);
```

```python
from os import environ
from web3 import Web3

w3 = Web3(Web3.HTTPProvider(
    "https://rpc.goldrushdata.com/v1/arbitrum-mainnet",
    request_kwargs={
        "headers": {
            "Authorization": f"Bearer {environ['GOLDRUSH_API_KEY']}",
        },
    },
))
result = w3.manager.request_blocking("eth_maxPriorityFeePerGas", [])
print(result)
```

--------------------------------

### net_listening implementation examples

Source: https://goldrush.dev/docs/api-reference/json-rpc/bsc/net-listening

Examples of how to call net_listening using various tools and libraries.

```bash
curl https://rpc.goldrushdata.com/v1/bsc-mainnet \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "net_listening",
    "params": []
  }'
```

```javascript
import { ethers } from "ethers";

const url = "https://rpc.goldrushdata.com/v1/bsc-mainnet";
const fetchReq = new ethers.FetchRequest(url);
fetchReq.setHeader("Authorization", `Bearer ${process.env.GOLDRUSH_API_KEY}`);

const provider = new ethers.JsonRpcProvider(fetchReq);
const result = await provider.send("net_listening", []);
console.log(result);
```

```javascript
import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://rpc.goldrushdata.com/v1/bsc-mainnet", {
    fetchOptions: {
      headers: {
        Authorization: `Bearer ${process.env.GOLDRUSH_API_KEY}`,
      },
    },
  }),
});

const result = await client.request({
  method: "net_listening",
  params: [],
});
console.log(result);
```

```javascript
import { Web3 } from "web3";

const provider = new Web3.providers.HttpProvider(
  "https://rpc.goldrushdata.com/v1/bsc-mainnet",
  {
    headers: [
      { name: "Authorization", value: `Bearer ${process.env.GOLDRUSH_API_KEY}` },
    ],
  }
);
const web3 = new Web3(provider);

const result = await web3.currentProvider.request({
  method: "net_listening",
  params: [],
});
console.log(result);
```

```python
from os import environ
from web3 import Web3

w3 = Web3(Web3.HTTPProvider(
    "https://rpc.goldrushdata.com/v1/bsc-mainnet",
    request_kwargs={
        "headers": {
            "Authorization": f"Bearer {environ['GOLDRUSH_API_KEY']}",
        },
    },
))
result = w3.manager.request_blocking("net_listening", [])
print(result)
```

--------------------------------

### Implementation Examples

Source: https://goldrush.dev/docs/api-reference/json-rpc/bsc/eth-getproof

Code examples for calling eth_getProof using various tools and libraries.

```bash
curl https://rpc.goldrushdata.com/v1/bsc-mainnet \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_getProof",
    "params": ["0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", ["0x0000000000000000000000000000000000000000000000000000000000000000"], "latest"]
  }'
```

```javascript
import { ethers } from "ethers";

const url = "https://rpc.goldrushdata.com/v1/bsc-mainnet";
const fetchReq = new ethers.FetchRequest(url);
fetchReq.setHeader("Authorization", `Bearer ${process.env.GOLDRUSH_API_KEY}`);

const provider = new ethers.JsonRpcProvider(fetchReq);
const result = await provider.send("eth_getProof", ["0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", ["0x0000000000000000000000000000000000000000000000000000000000000000"], "latest"]);
console.log(result);
```

```javascript
import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://rpc.goldrushdata.com/v1/bsc-mainnet", {
    fetchOptions: {
      headers: {
        Authorization: `Bearer ${process.env.GOLDRUSH_API_KEY}`,
      },
    },
  }),
});

const result = await client.request({
  method: "eth_getProof",
  params: ["0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", ["0x0000000000000000000000000000000000000000000000000000000000000000"], "latest"],
});
console.log(result);
```

```javascript
import { Web3 } from "web3";

const provider = new Web3.providers.HttpProvider(
  "https://rpc.goldrushdata.com/v1/bsc-mainnet",
  {
    headers: [
      { name: "Authorization", value: `Bearer ${process.env.GOLDRUSH_API_KEY}` },
    ],
  }
);
const web3 = new Web3(provider);

const result = await web3.currentProvider.request({
  method: "eth_getProof",
  params: ["0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", ["0x0000000000000000000000000000000000000000000000000000000000000000"], "latest"],
});
console.log(result);
```

```python
from os import environ
from web3 import Web3

w3 = Web3(Web3.HTTPProvider(
    "https://rpc.goldrushdata.com/v1/bsc-mainnet",
    request_kwargs={
        "headers": {
            "Authorization": f"Bearer {environ['GOLDRUSH_API_KEY']}",
        },
    },
))
result = w3.manager.request_blocking("eth_getProof", ["0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", ["0x0000000000000000000000000000000000000000000000000000000000000000"], "latest"])
print(result)
```

--------------------------------

### Request Examples

Source: https://goldrush.dev/docs/api-reference/json-rpc/hyperevm/eth-getblocktransactioncountbynumber

Examples of how to call eth_getBlockTransactionCountByNumber using various tools and libraries.

```bash
curl https://rpc.goldrushdata.com/v1/hyperevm-mainnet \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_getBlockTransactionCountByNumber",
    "params": ["latest"]
  }'
```

```javascript
import { ethers } from "ethers";

const url = "https://rpc.goldrushdata.com/v1/hyperevm-mainnet";
const fetchReq = new ethers.FetchRequest(url);
fetchReq.setHeader("Authorization", `Bearer ${process.env.GOLDRUSH_API_KEY}`);

const provider = new ethers.JsonRpcProvider(fetchReq);
const result = await provider.send("eth_getBlockTransactionCountByNumber", ["latest"]);
console.log(result);
```

```javascript
import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://rpc.goldrushdata.com/v1/hyperevm-mainnet", {
    fetchOptions: {
      headers: {
        Authorization: `Bearer ${process.env.GOLDRUSH_API_KEY}`,
      },
    },
  }),
});

const result = await client.request({
  method: "eth_getBlockTransactionCountByNumber",
  params: ["latest"],
});
console.log(result);
```

```javascript
import { Web3 } from "web3";

const provider = new Web3.providers.HttpProvider(
  "https://rpc.goldrushdata.com/v1/hyperevm-mainnet",
  {
    headers: [
      { name: "Authorization", value: `Bearer ${process.env.GOLDRUSH_API_KEY}` },
    ],
  }
);
const web3 = new Web3(provider);

const result = await web3.currentProvider.request({
  method: "eth_getBlockTransactionCountByNumber",
  params: ["latest"],
});
console.log(result);
```

```python
from os import environ
from web3 import Web3

w3 = Web3(Web3.HTTPProvider(
    "https://rpc.goldrushdata.com/v1/hyperevm-mainnet",
    request_kwargs={
        "headers": {
            "Authorization": f"Bearer {environ['GOLDRUSH_API_KEY']}",
        },
    },
))
result = w3.manager.request_blocking("eth_getBlockTransactionCountByNumber", ["latest"])
print(result)
```

--------------------------------

### eth_accounts Request Examples

Source: https://goldrush.dev/docs/api-reference/json-rpc/ethereum/eth-accounts

Examples of how to call eth_accounts using various tools and libraries.

```bash
curl https://rpc.goldrushdata.com/v1/eth-mainnet \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_accounts",
    "params": []
  }'
```

```javascript
import { ethers } from "ethers";

const url = "https://rpc.goldrushdata.com/v1/eth-mainnet";
const fetchReq = new ethers.FetchRequest(url);
fetchReq.setHeader("Authorization", `Bearer ${process.env.GOLDRUSH_API_KEY}`);

const provider = new ethers.JsonRpcProvider(fetchReq);
const result = await provider.send("eth_accounts", []);
console.log(result);
```

```typescript
import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://rpc.goldrushdata.com/v1/eth-mainnet", {
    fetchOptions: {
      headers: {
        Authorization: `Bearer ${process.env.GOLDRUSH_API_KEY}`,
      },
    },
  }),
});

const result = await client.request({
  method: "eth_accounts",
  params: [],
});
console.log(result);
```

```javascript
import { Web3 } from "web3";

const provider = new Web3.providers.HttpProvider(
  "https://rpc.goldrushdata.com/v1/eth-mainnet",
  {
    headers: [
      { name: "Authorization", value: `Bearer ${process.env.GOLDRUSH_API_KEY}` },
    ],
  }
);
const web3 = new Web3(provider);

const result = await web3.currentProvider.request({
  method: "eth_accounts",
  params: [],
});
console.log(result);
```

```python
from os import environ
from web3 import Web3

w3 = Web3(Web3.HTTPProvider(
    "https://rpc.goldrushdata.com/v1/eth-mainnet",
    request_kwargs={
        "headers": {
            "Authorization": f"Bearer {environ['GOLDRUSH_API_KEY']}",
        },
    },
))
result = w3.manager.request_blocking("eth_accounts", [])
print(result)
```

--------------------------------

### getEpochSchedule Examples

Source: https://goldrush.dev/docs/api-reference/json-rpc/solana/getepochschedule

Examples showing how to call getEpochSchedule using cURL, @solana/kit, and Python.

```bash
curl https://rpc.goldrushdata.com/v1/solana-mainnet \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getEpochSchedule",
    "params": []
  }'
```

```typescript
import {
  createDefaultRpcTransport,
  createSolanaRpcFromTransport,
} from "@solana/kit";

const transport = createDefaultRpcTransport({
  url: "https://rpc.goldrushdata.com/v1/solana-mainnet",
  headers: { Authorization: `Bearer ${process.env.GOLDRUSH_API_KEY}` },
});
const rpc = createSolanaRpcFromTransport(transport);

const result = await rpc.getEpochSchedule().send();
console.log(result);
```

```python
import os
import requests

resp = requests.post(
    "https://rpc.goldrushdata.com/v1/solana-mainnet",
    headers={
        "Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}",
        "Content-Type": "application/json",
    },
    json={"jsonrpc": "2.0", "id": 1, "method": "getEpochSchedule", "params": []},
)
print(resp.json()["result"])
```

--------------------------------

### GET /v3/{chain_id}/address/{address}/transactions_v2/

Source: https://goldrush.dev/docs/api-reference/foundational-api/transactions/get-paginated-transactions-for-address-v3

Fetches paginated transactions for a given address, starting from the earliest transactions.

```APIDOC
## GET /v3/{chain_id}/address/{address}/transactions_v2/

### Description
Fetches the transactions involving an address including the decoded log events in a paginated fashion. This endpoint starts with the earliest transactions on page 0.

### Method
GET

### Endpoint
/v3/{chain_id}/address/{address}/transactions_v2/

### Parameters
#### Path Parameters
- **chain_id** (string) - Required - The ID of the blockchain network.
- **address** (string) - Required - The wallet address to fetch transactions for.

#### Query Parameters
- **no-logs** (boolean) - Optional - If enabled, reduces request cost to 0.05 credits/item.
- **with-internal** (boolean) - Optional - If enabled, includes internal transactions in the response (supported on select EVM chains only).
```

--------------------------------

### programSubscribe Examples

Source: https://goldrush.dev/docs/api-reference/json-rpc/solana/programsubscribe

Examples showing how to initiate a program subscription using wscat or the @solana/kit library.

```bash
# Connect (header auth works from Node/CLI clients):
wscat -c "wss://rpc.goldrushdata.com/v1/solana-mainnet" \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY"

# Once connected, send:
{"jsonrpc":"2.0","id":1,"method":"programSubscribe","params":["TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", {"encoding":"jsonParsed","filters":[{"dataSize":165}]}]}
```

```typescript
import { createSolanaRpcSubscriptions } from "@solana/kit";

// Authenticate with the Authorization: Bearer header on the WS handshake.
// See /goldrush-json-rpc/authentication.
const rpcSubscriptions = createSolanaRpcSubscriptions("wss://rpc.goldrushdata.com/v1/solana-mainnet");

const abortController = new AbortController();
const notifications = await rpcSubscriptions
  .programSubscribe("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", {"encoding":"jsonParsed","filters":[{"dataSize":165}]})
  .subscribe({ abortSignal: abortController.signal });

for await (const notification of notifications) {
  console.log(notification);
}
```

--------------------------------

### accountSubscribe Examples

Source: https://goldrush.dev/docs/api-reference/json-rpc/solana/accountsubscribe

Examples demonstrating how to initiate an account subscription using wscat or the @solana/kit library.

```bash
# Connect (header auth works from Node/CLI clients):
wscat -c "wss://rpc.goldrushdata.com/v1/solana-mainnet" \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY"

# Once connected, send:
{"jsonrpc":"2.0","id":1,"method":"accountSubscribe","params":["CM78CPUeXjn8o3yroDHxUtKsZZgoy4GPkPPXfouKNH12", {"encoding":"jsonParsed","commitment":"finalized"}]}
```

```typescript
import { createSolanaRpcSubscriptions } from "@solana/kit";

// Authenticate with the Authorization: Bearer header on the WS handshake.
// See /goldrush-json-rpc/authentication.
const rpcSubscriptions = createSolanaRpcSubscriptions("wss://rpc.goldrushdata.com/v1/solana-mainnet");

const abortController = new AbortController();
const notifications = await rpcSubscriptions
  .accountSubscribe("CM78CPUeXjn8o3yroDHxUtKsZZgoy4GPkPPXfouKNH12", {"encoding":"jsonParsed","commitment":"finalized"})
  .subscribe({ abortSignal: abortController.signal });

for await (const notification of notifications) {
  console.log(notification);
}
```

--------------------------------

### Fetch Block Number via cURL

Source: https://goldrush.dev/docs/api-reference/json-rpc/chains/monad

A quickstart example demonstrating how to retrieve the latest block number from the Monad network using the eth_blockNumber method.

```bash
curl https://rpc.goldrushdata.com/v1/monad-mainnet \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_blockNumber",
    "params": []
  }'
```

--------------------------------

### signatureSubscribe Examples

Source: https://goldrush.dev/docs/api-reference/json-rpc/solana/signaturesubscribe

Examples showing how to initiate a signature subscription using wscat or the @solana/kit library.

```bash
# Connect (header auth works from Node/CLI clients):
wscat -c "wss://rpc.goldrushdata.com/v1/solana-mainnet" \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY"

# Once connected, send:
{"jsonrpc":"2.0","id":1,"method":"signatureSubscribe","params":["5VERv8NMvzbJMEkV8xnrLkEaWRtSz9CosKDYjCJjBRnbJLgp8uirBgmQpjKhoR4tjF3ZpRzrFmBV6UjKdiSZkQUW", {"commitment":"finalized"}]}
```

```typescript
import { createSolanaRpcSubscriptions } from "@solana/kit";

// Authenticate with the Authorization: Bearer header on the WS handshake.
// See /goldrush-json-rpc/authentication.
const rpcSubscriptions = createSolanaRpcSubscriptions("wss://rpc.goldrushdata.com/v1/solana-mainnet");

const abortController = new AbortController();
const notifications = await rpcSubscriptions
  .signatureSubscribe("5VERv8NMvzbJMEkV8xnrLkEaWRtSz9CosKDYjCJjBRnbJLgp8uirBgmQpjKhoR4tjF3ZpRzrFmBV6UjKdiSZkQUW", {"commitment":"finalized"})
  .subscribe({ abortSignal: abortController.signal });

for await (const notification of notifications) {
  console.log(notification);
}
```

--------------------------------

### Install GoldRush SDK

Source: https://goldrush.dev/docs/goldrush-foundational-api/quickstart

Install the SDK using npm or yarn.

```bash
npm install @covalenthq/client-sdk
```

```bash
yarn add @covalenthq/client-sdk
```

--------------------------------

### trace_filter Parameter Example

Source: https://goldrush.dev/docs/api-reference/json-rpc/tempo/trace-filter

Example JSON object for the filter parameter.

```json
{"fromBlock":"0x14a3b8c","toBlock":"latest","fromAddress":["0xd8da6bf2..."]}
```

--------------------------------

### blockSubscribe Examples

Source: https://goldrush.dev/docs/api-reference/json-rpc/solana/blocksubscribe

Examples showing how to initiate a block subscription using wscat or the @solana/kit library.

```bash
# Connect (header auth works from Node/CLI clients):
wscat -c "wss://rpc.goldrushdata.com/v1/solana-mainnet" \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY"

# Once connected, send:
{"jsonrpc":"2.0","id":1,"method":"blockSubscribe","params":["all", {"commitment":"confirmed","encoding":"jsonParsed","maxSupportedTransactionVersion":0,"transactionDetails":"full","showRewards":true}]}
```

```typescript
import { createSolanaRpcSubscriptions } from "@solana/kit";

// Authenticate with the Authorization: Bearer header on the WS handshake.
// See /goldrush-json-rpc/authentication.
const rpcSubscriptions = createSolanaRpcSubscriptions("wss://rpc.goldrushdata.com/v1/solana-mainnet");

const abortController = new AbortController();
const notifications = await rpcSubscriptions
  .blockSubscribe("all", {"commitment":"confirmed","encoding":"jsonParsed","maxSupportedTransactionVersion":0,"transactionDetails":"full","showRewards":true})
  .subscribe({ abortSignal: abortController.signal });

for await (const notification of notifications) {
  console.log(notification);
}
```

--------------------------------

### Configuration Object Example

Source: https://goldrush.dev/docs/api-reference/json-rpc/solana/sendtransaction

An example configuration object for the sendTransaction method.

```json
{"encoding":"base64","skipPreflight":false,"preflightCommitment":"confirmed","maxRetries":5}
```

--------------------------------

### Return Value Example

Source: https://goldrush.dev/docs/api-reference/json-rpc/solana/getblocktime

An example of the Unix timestamp returned by the API.

```text
1718000000
```

--------------------------------

### Return Value Example

Source: https://goldrush.dev/docs/api-reference/json-rpc/arbitrum/eth-syncing

Example response when the node is fully synced.

```json
false
```

--------------------------------

### Install Hyperliquid Python SDK

Source: https://goldrush.dev/docs/goldrush-hyperliquid/info-api/sdk-compatibility

Command to install the Hyperliquid Python SDK.

```bash
pip install hyperliquid-python-sdk
```

--------------------------------

### eth_uninstallFilter Implementation Examples

Source: https://goldrush.dev/docs/api-reference/json-rpc/arbitrum/eth-uninstallfilter

Examples demonstrating how to call eth_uninstallFilter across various programming languages and libraries.

```bash
curl https://rpc.goldrushdata.com/v1/arbitrum-mainnet \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_uninstallFilter",
    "params": ["0x16"]
  }'
```

```javascript
import { ethers } from "ethers";

const url = "https://rpc.goldrushdata.com/v1/arbitrum-mainnet";
const fetchReq = new ethers.FetchRequest(url);
fetchReq.setHeader("Authorization", `Bearer ${process.env.GOLDRUSH_API_KEY}`);

const provider = new ethers.JsonRpcProvider(fetchReq);
const result = await provider.send("eth_uninstallFilter", ["0x16"]);
console.log(result);
```

```javascript
import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://rpc.goldrushdata.com/v1/arbitrum-mainnet", {
    fetchOptions: {
      headers: {
        Authorization: `Bearer ${process.env.GOLDRUSH_API_KEY}`,
      },
    },
  }),
});

const result = await client.request({
  method: "eth_uninstallFilter",
  params: ["0x16"],
});
console.log(result);
```

```javascript
import { Web3 } from "web3";

const provider = new Web3.providers.HttpProvider(
  "https://rpc.goldrushdata.com/v1/arbitrum-mainnet",
  {
    headers: [
      { name: "Authorization", value: `Bearer ${process.env.GOLDRUSH_API_KEY}` },
    ],
  }
);
const web3 = new Web3(provider);

const result = await web3.currentProvider.request({
  method: "eth_uninstallFilter",
  params: ["0x16"],
});
console.log(result);
```

```python
from os import environ
from web3 import Web3

w3 = Web3(Web3.HTTPProvider(
    "https://rpc.goldrushdata.com/v1/arbitrum-mainnet",
    request_kwargs={
        "headers": {
            "Authorization": f"Bearer {environ['GOLDRUSH_API_KEY']}",
        },
    },
))
result = w3.manager.request_blocking("eth_uninstallFilter", ["0x16"])
print(result)
```

--------------------------------

### eth_gasPrice Implementation Examples

Source: https://goldrush.dev/docs/api-reference/json-rpc/bsc/eth-gasprice

Examples showing how to call eth_gasPrice using various tools and libraries with authentication.

```bash
curl https://rpc.goldrushdata.com/v1/bsc-mainnet \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_gasPrice",
    "params": []
  }'
```

```javascript
import { ethers } from "ethers";

const url = "https://rpc.goldrushdata.com/v1/bsc-mainnet";
const fetchReq = new ethers.FetchRequest(url);
fetchReq.setHeader("Authorization", `Bearer ${process.env.GOLDRUSH_API_KEY}`);

const provider = new ethers.JsonRpcProvider(fetchReq);
const result = await provider.send("eth_gasPrice", []);
console.log(result);
```

```typescript
import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://rpc.goldrushdata.com/v1/bsc-mainnet", {
    fetchOptions: {
      headers: {
        Authorization: `Bearer ${process.env.GOLDRUSH_API_KEY}`,
      },
    },
  }),
});

const result = await client.request({
  method: "eth_gasPrice",
  params: [],
});
console.log(result);
```

```javascript
import { Web3 } from "web3";

const provider = new Web3.providers.HttpProvider(
  "https://rpc.goldrushdata.com/v1/bsc-mainnet",
  {
    headers: [
      { name: "Authorization", value: `Bearer ${process.env.GOLDRUSH_API_KEY}` },
    ],
  }
);
const web3 = new Web3(provider);

const result = await web3.currentProvider.request({
  method: "eth_gasPrice",
  params: [],
});
console.log(result);
```

```python
from os import environ
from web3 import Web3

w3 = Web3(Web3.HTTPProvider(
    "https://rpc.goldrushdata.com/v1/bsc-mainnet",
    request_kwargs={
        "headers": {
            "Authorization": f"Bearer {environ['GOLDRUSH_API_KEY']}",
        },
    },
))
result = w3.manager.request_blocking("eth_gasPrice", [])
print(result)
```

--------------------------------

### Transaction Parameter Example

Source: https://goldrush.dev/docs/api-reference/json-rpc/solana/sendtransaction

An example of a fully-signed transaction encoded as a base64 string.

```json
"AR4KbO6uYPS5PKSh8u1ah2Jq1pHeXwaojuxdDGbSSumHcCM1bukbYaDt5/wiqiIwP156mLvzJxk3ILQocD3W8wcBAAIEwS6EMxyDU3PzY4L5Q52OIthyvkPczZiNOrY0kYo1V1oNwwgfIhv6odn2qTUu/gOisDtaeCW1qlwW/gx3ccr/4wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwZGb+UhFzL/7K26csOb57yM5bvF9xJrLEObOkAAAACmNAYg3PP4Wwb6+EaGmhEew4gOOjQBZwBCR73i+EDMaAMDAAkDgNHwCAAAAAADAAUC9AEAAAICAAEMAgAAAKCGAQAAAAAA"
```

--------------------------------

### Return Value Example

Source: https://goldrush.dev/docs/api-reference/json-rpc/solana/getminimumbalanceforrentexemption

Example of the numeric lamport balance returned by the API.

```text
2039280
```

--------------------------------

### eth_getCode Implementation Examples

Source: https://goldrush.dev/docs/api-reference/json-rpc/ethereum/eth-getcode

Examples showing how to call eth_getCode using various tools and libraries.

```bash
curl https://rpc.goldrushdata.com/v1/eth-mainnet \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_getCode",
    "params": ["0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", "latest"]
  }'
```

```javascript
import { ethers } from "ethers";

const url = "https://rpc.goldrushdata.com/v1/eth-mainnet";
const fetchReq = new ethers.FetchRequest(url);
fetchReq.setHeader("Authorization", `Bearer ${process.env.GOLDRUSH_API_KEY}`);

const provider = new ethers.JsonRpcProvider(fetchReq);
const result = await provider.send("eth_getCode", ["0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", "latest"]);
console.log(result);
```

```javascript
import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://rpc.goldrushdata.com/v1/eth-mainnet", {
    fetchOptions: {
      headers: {
        Authorization: `Bearer ${process.env.GOLDRUSH_API_KEY}`,
      },
    },
  }),
});

const result = await client.request({
  method: "eth_getCode",
  params: ["0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", "latest"],
});
console.log(result);
```

```javascript
import { Web3 } from "web3";

const provider = new Web3.providers.HttpProvider(
  "https://rpc.goldrushdata.com/v1/eth-mainnet",
  {
    headers: [
      { name: "Authorization", value: `Bearer ${process.env.GOLDRUSH_API_KEY}` },
    ],
  }
);
const web3 = new Web3(provider);

const result = await web3.currentProvider.request({
  method: "eth_getCode",
  params: ["0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", "latest"],
});
console.log(result);
```

```python
from os import environ
from web3 import Web3

w3 = Web3(Web3.HTTPProvider(
    "https://rpc.goldrushdata.com/v1/eth-mainnet",
    request_kwargs={
        "headers": {
            "Authorization": f"Bearer {environ['GOLDRUSH_API_KEY']}",
        },
    },
))
result = w3.manager.request_blocking("eth_getCode", ["0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", "latest"])
print(result)
```

--------------------------------

### getInflationRate Examples

Source: https://goldrush.dev/docs/api-reference/json-rpc/solana/getinflationrate

Examples for calling getInflationRate using cURL, @solana/kit, and Python.

```bash
curl https://rpc.goldrushdata.com/v1/solana-mainnet \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getInflationRate",
    "params": []
  }'
```

```typescript
import {
  createDefaultRpcTransport,
  createSolanaRpcFromTransport,
} from "@solana/kit";

const transport = createDefaultRpcTransport({
  url: "https://rpc.goldrushdata.com/v1/solana-mainnet",
  headers: { Authorization: `Bearer ${process.env.GOLDRUSH_API_KEY}` },
});
const rpc = createSolanaRpcFromTransport(transport);

const result = await rpc.getInflationRate().send();
console.log(result);
```

```python
import os
import requests

resp = requests.post(
    "https://rpc.goldrushdata.com/v1/solana-mainnet",
    headers={
        "Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}",
        "Content-Type": "application/json",
    },
    json={"jsonrpc": "2.0", "id": 1, "method": "getInflationRate", "params": []},
)
print(resp.json()["result"])
```

--------------------------------

### getLargestAccounts Examples

Source: https://goldrush.dev/docs/api-reference/json-rpc/solana/getlargestaccounts

Examples for calling getLargestAccounts using cURL, @solana/kit, and Python.

```bash
curl https://rpc.goldrushdata.com/v1/solana-mainnet \
  -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getLargestAccounts",
    "params": [{"filter":"circulating"}]
  }'
```

```typescript
import {
  createDefaultRpcTransport,
  createSolanaRpcFromTransport,
} from "@solana/kit";

const transport = createDefaultRpcTransport({
  url: "https://rpc.goldrushdata.com/v1/solana-mainnet",
  headers: { Authorization: `Bearer ${process.env.GOLDRUSH_API_KEY}` },
});
const rpc = createSolanaRpcFromTransport(transport);

const result = await rpc.getLargestAccounts({"filter":"circulating"}).send();
console.log(result);
```

```python
import os
import requests

resp = requests.post(
    "https://rpc.goldrushdata.com/v1/solana-mainnet",
    headers={
        "Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}",
        "Content-Type": "application/json",
    },
    json={"jsonrpc": "2.0", "id": 1, "method": "getLargestAccounts", "params": [{"filter":"circulating"}]},
)
print(resp.json()["result"])
```
Tokens:
Raw