Dwellir

https://www.dwellir.com/docs
Admin
Dwellir is an enterprise-grade RPC infrastructure provider offering 99.99% uptime SLA and access to...
Tokens:2,680,648
Snippets:26,263
Trust Score:8.4
Update:2 months ago
Show doc for...
Tokens:
Raw
### Setup Celo Development Environment

Source: https://www.dwellir.com/docs/celo

Install the Celo CLI, initialize a React project, and add necessary dependencies.

```bash
# Celo - Mobile-First Blockchain Platform Documentation
npm install -g @celo/celocli

# Create new project
npx create-react-app my-celo-dapp
cd my-celo-dapp

# Install Celo dependencies
npm install @celo/contractkit ethers
```

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

### Install and Authenticate with Dwellir CLI

Source: https://www.dwellir.com/docs/cli

Initial setup commands to install the CLI, authenticate, and perform basic discovery tasks.

```bash
# Install
curl -fsSL https://raw.githubusercontent.com/dwellir-public/cli/main/scripts/install.sh | sh

# Authenticate
dwellir auth login

# List your API keys
dwellir keys list

# Discover Ethereum endpoints
dwellir endpoints search ethereum
```

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

### Implementation Examples

Source: https://www.dwellir.com/docs/neuroweb/eth_maxPriorityFeePerGas

Examples showing how to call the method using cURL and JavaScript.

```bash
curl -X POST https://api-neuroweb.n.dwellir.com/YOUR_API_KEY \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_maxPriorityFeePerGas",
    "params": [],
    "id": 1
  }'
```

```javascript
const response = await fetch('https://api-neuroweb.n.dwellir.com/YOUR_API_KEY', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    method: 'eth_maxPriorityFeePerGas',
    params: [],
    id: 1
  })
});

const data = await response.json();
console.log(data.result);
```

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

### cURL Request Examples

Source: https://www.dwellir.com/docs/mythos/state_getKeysPaged

Executing state_getKeysPaged via cURL, including a pagination example using a start key.

```bash
# state_getKeysPaged - Mythos RPC Method
curl -X POST https://api-mythos-archive.n.dwellir.com/YOUR_API_KEY \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "state_getKeysPaged",
    "params": [
      "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9",
      10
    ],
    "id": 1
  }'

# Continue from the last key (pagination)
curl -X POST https://api-mythos-archive.n.dwellir.com/YOUR_API_KEY \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "state_getKeysPaged",
    "params": [
      "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9",
      10,
      "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da905c4d73a68eff3a32b6af8adc29e8fc0be"
    ],
    "id": 1
  }'
```

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

### Request Example (wscat)

Source: https://www.dwellir.com/docs/bittensor/chain_subscribeAllHeads

Example of initiating the subscription using the wscat command-line tool.

```bash
wscat -c wss://api-bittensor-mainnet.n.dwellir.com/YOUR_API_KEY \
  -x '{
    "jsonrpc": "2.0",
    "method": "chain_subscribeAllHeads",
    "params": [],
    "id": 1
  }'
```

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

### Go Implementation Example

Source: https://www.dwellir.com/docs/ethereum/eth_maxPriorityFeePerGas

Example using the go-ethereum client to retrieve the suggested gas tip.

```go
package main

import (
    "context"
    "fmt"
    "log"
    "math/big"

    "github.com/ethereum/go-ethereum/ethclient"
)

func main() {
    client, err := ethclient.Dial("https://api-ethereum-mainnet.n.dwellir.com/YOUR_API_KEY")
    if err != nil {
        log.Fatal(err)
    }

    tip, err := client.SuggestGasTipCap(context.Background())
    if err != nil {
        log.Fatal(err)
    }

    gwei := new(big.Float).Quo(new(big.Float).SetInt(tip), big.NewFloat(1e9))
    fmt.Printf("Ethereum priority fee: %s Gwei\n", gwei.Text('f', 4))
}
```

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

### Run Example Script

Source: https://www.dwellir.com/docs/sui/grpc-setup-python

Commands to activate the virtual environment and execute the example script.

```bash
# Activate virtual environment (if not already active)
source venv/bin/activate  # On macOS/Linux
# or
.\venv\Scripts\activate   # On Windows

# Run the example
python example_get_checkpoint.py
```

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

### cURL Request Examples

Source: https://www.dwellir.com/docs/acala/state_getKeysPaged

Examples for calling the RPC method via cURL, including a standard request and a paginated request using a start key.

```bash
# state_getKeysPaged - Acala RPC Method
curl -X POST https://api-acala.n.dwellir.com/YOUR_API_KEY \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "state_getKeysPaged",
    "params": [
      "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9",
      10
    ],
    "id": 1
  }'

# Continue from the last key (pagination)
curl -X POST https://api-acala.n.dwellir.com/YOUR_API_KEY \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "state_getKeysPaged",
    "params": [
      "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9",
      10,
      "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da905c4d73a68eff3a32b6af8adc29e8fc0be"
    ],
    "id": 1
  }'
```

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

### Get Contract Info via cURL

Source: https://www.dwellir.com/docs/tron/wallet-getcontractinfo

Examples for querying contract information using visible or hex addresses, including an example of piping output to jq.

```bash
# Get contract info with visible address
curl -X POST https://api-tron-mainnet.n.dwellir.com/YOUR_API_KEY/wallet/getcontractinfo \
  -H "Content-Type: application/json" \
  -d '{
    "value": "TContractAddress...",
    "visible": true
  }'

# Get contract info with hex address
curl -X POST https://api-tron-mainnet.n.dwellir.com/YOUR_API_KEY/wallet/getcontractinfo \
  -H "Content-Type: application/json" \
  -d '{
    "value": "41a614f803b6fd780986a42c78ec9c7f77e6ded13c"
  }'

# Extract ABI using jq
curl -X POST https://api-tron-mainnet.n.dwellir.com/YOUR_API_KEY/wallet/getcontractinfo \
  -H "Content-Type: application/json" \
  -d '{
    "value": "TContractAddress...",
    "visible": true
  }' | jq '.abi.entrys[] | select(.type == "Function") | .name'
```

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

### Client Implementation Examples

Source: https://www.dwellir.com/docs/avalanche/rpc_modules

Examples of how to call rpc_modules using various programming languages and tools.

```bash
curl -X POST https://api-avalanche-mainnet-archive.n.dwellir.com/YOUR_API_KEY/ext/bc/C/rpc \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "rpc_modules",
    "params": [],
    "id": 1
  }'
```

```javascript
import { JsonRpcProvider } from 'ethers';

const provider = new JsonRpcProvider('https://api-avalanche-mainnet-archive.n.dwellir.com/YOUR_API_KEY/ext/bc/C/rpc');

const modules = await provider.send('rpc_modules', []);
console.log('Namespaces:', Object.keys(modules));

if (modules.debug) {
  console.log('Debug RPC is enabled');
}
```

```python
import requests

response = requests.post(
    'https://api-avalanche-mainnet-archive.n.dwellir.com/YOUR_API_KEY/ext/bc/C/rpc',
    json={
        'jsonrpc': '2.0',
        'method': 'rpc_modules',
        'params': [],
        'id': 1,
    },
)

modules = response.json()['result']
print('Namespaces:', sorted(modules.keys()))
print('Has trace:', 'trace' in modules)
```

```go
package main

import (
    "context"
    "fmt"
    "log"
    "sort"

    "github.com/ethereum/go-ethereum/rpc"
)

func main() {
    client, err := rpc.Dial("https://api-avalanche-mainnet-archive.n.dwellir.com/YOUR_API_KEY/ext/bc/C/rpc")
    if err != nil {
        log.Fatal(err)
    }

    var modules map[string]string
    err = client.CallContext(context.Background(), &modules, "rpc_modules")
    if err != nil {
        log.Fatal(err)
    }

    names := make([]string, 0, len(modules))
    for name := range modules {
        names = append(names, name)
    }
    sort.Strings(names)
    fmt.Printf("Namespaces: %v\n", names)
}
```

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

### Staking and APY Usage Examples

Source: https://www.dwellir.com/docs/sui/suix_getValidatorsApy

Examples demonstrating how to fetch APY data, analyze validator rewards, optimize staking strategies, and start APY monitoring.

```javascript
// Usage examples
// Get basic APY data
const apyData = await getValidatorsApy();
console.log(`APY data for ${apyData.length} validators`);

// Detailed validator analysis
const detailedValidators = await analyzeValidatorRewards();
console.log('Detailed validator data loaded');

// Find optimal staking strategy
const optimizer = new StakingOptimizer(client);
const strategy = await optimizer.findOptimalValidators(10000000000000, { // 10K SUI in MIST
  minApy: 0.04,
  maxCommission: 0.07,
  diversificationCount: 3,
  riskTolerance: 'medium'
});

console.log('\nOptimal Staking Strategy:');
console.log(`Expected Annual Return: ${(strategy.totalExpectedReturn / 1000000000).toFixed(2)} SUI`);
console.log(`Weighted Average APY: ${(strategy.weightedAverageApy * 100).toFixed(2)}%`);

strategy.recommendations.forEach((rec, index) => {
  console.log(`\n${index + 1}. ${rec.validator.name}`);
  console.log(`   Amount: ${(rec.recommendedAmount / 1000000000).toFixed(2)} SUI`);
  console.log(`   APY: ${(rec.validator.apy * 100).toFixed(2)}%`);
  console.log(`   Expected Return: ${(rec.expectedAnnualReturn / 1000000000).toFixed(2)} SUI`);
  console.log(`   Reasoning: ${rec.reasoning}`);
});

// Start APY monitoring
const apyTracker = new APYTracker(client);
const stopMonitoring = await apyTracker.startMonitoring(120); // Check every 2 hours
```

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

### JavaScript Usage Examples

Source: https://www.dwellir.com/docs/tron/wallet-getnodeinfo

Demonstrates how to initialize the monitor, fetch status, and handle alerts.

```javascript
(async () => {
  const monitor = new TronNodeMonitor('YOUR_API_KEY');
  
  try {
    // Get basic status
    const status = await monitor.getStatus();
    console.log('Node Status:', status);
    
    // Get detailed information
    const detailed = await monitor.getDetailedInfo();
    console.log('Detailed Info:', detailed);
    
    // Set up health monitoring
    monitor.onAlert = (alert) => {
      console.log(`[${alert.level.toUpperCase()}] ${alert.message}`);
    };
    
    const monitorHandle = await monitor.monitorHealth(60000);
    
    // Start dashboard (if in browser)
    if (typeof document !== 'undefined') {
      const dashboard = new NodeDashboard('YOUR_API_KEY');
      await dashboard.start('node-status', 30000);
    }
    
    // Stop monitoring after 5 minutes
    setTimeout(() => {
      clearInterval(monitorHandle);
      console.log('Monitoring stopped');
    }, 5 * 60 * 1000);
    
  } catch (error) {
    console.error('Error:', error);
  }
})();
```

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

### Monitoring Initialization and Output

Source: https://www.dwellir.com/docs/sui/suix_getLatestSuiSystemState

Example of how to initialize the monitor and a sample of the expected console output.

```javascript
// Start system monitoring (uncomment to run continuously)
// const monitor = new SystemStateMonitor(client);
// const stopMonitoring = await monitor.startMonitoring(10); // Check every 10 minutes

// Example monitoring output
console.log('\n📊 Example Monitoring Output:');
console.log('🔍 Starting system state monitoring (every 10 minutes)');
console.log('📊 System Status - Epoch 251');
console.log('   Validators: 120');
console.log('   Total Stake: 2,500,000 SUI');
console.log('   Gas Price: 1000 MIST');
console.log('   Safe Mode: INACTIVE');
console.log('🔵 [INFO] New epoch started: 250 → 251');
console.log('🟡 [WARNING] Reference gas price changed by +5.0% (1000 → 1050 MIST)');
```

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

### StreamRawBookDiffs Request Configuration

Source: https://www.dwellir.com/docs/hyperliquid/stream_raw_book_diffs

Example request structure specifying a starting block position and coin filters.

```protobuf
position: {
  block_number: 1058646974
}
filter: {
  fields: {
    field: "coins"
    op: FILTER_OP_IN
    values: "BTC"
    values: "ETH"
  }
}
```

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

### Request state_getKeysPagedAt

Source: https://www.dwellir.com/docs/bittensor/state_getKeysPagedAt

Example JSON-RPC request to fetch a page of storage keys starting from a null cursor.

```json
{
  "jsonrpc": "2.0",
  "method": "state_getKeysPagedAt",
  "params": [
    "0x3a636f6465",
    10,
    null,
    "0x1e8a700fa840157d8d5617eac90ecd3b795d6469ddb8a9ec7dd2d051d806e85d"
  ],
  "id": 1
}
```

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

### Install grpcurl from Source

Source: https://www.dwellir.com/docs/sui/grpc-setup-grpcurl

Use the Go toolchain to install the latest version directly from the repository.

```bash
go install github.com/fullstorydev/grpcurl/cmd/grpcurl@latest
```

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

### Client Implementation Examples

Source: https://www.dwellir.com/docs/bittensor/eth_protocolVersion

Examples for calling the eth_protocolVersion method using various programming languages.

```bash
curl -X POST https://api-bittensor-mainnet.n.dwellir.com/YOUR_API_KEY \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_protocolVersion",
    "params": [],
    "id": 1
  }'
```

```javascript
const response = await fetch('https://api-bittensor-mainnet.n.dwellir.com/YOUR_API_KEY', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    method: 'eth_protocolVersion',
    params: [],
    id: 1,
  }),
});

const { result } = await response.json();
const version = typeof result === 'string' ? Number(result) : result;

console.log('Bittensor protocol version:', version);
```

```python
import requests

response = requests.post(
    'https://api-bittensor-mainnet.n.dwellir.com/YOUR_API_KEY',
    json={
        'jsonrpc': '2.0',
        'method': 'eth_protocolVersion',
        'params': [],
        'id': 1,
    },
)

result = response.json()['result']
version = int(result)
print(f'Bittensor protocol version: {version}')
```

```go
package main

import (
    "context"
    "fmt"
    "log"

    "github.com/ethereum/go-ethereum/rpc"
)

func main() {
    client, err := rpc.Dial("https://api-bittensor-mainnet.n.dwellir.com/YOUR_API_KEY")
    if err != nil {
        log.Fatal(err)
    }

    var result int
    err = client.CallContext(context.Background(), &result, "eth_protocolVersion")
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Bittensor protocol version: %d\n", result)
}
```

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

### GET /docs/llms.txt

Source: https://www.dwellir.com/docs/agents

Retrieves a curated index of documentation, including network guides and key documentation pages.

```APIDOC
## GET /docs/llms.txt

### Description
Returns a curated index of documentation pages, specifically focusing on network guides and key documentation.

### Method
GET

### Endpoint
/docs/llms.txt
```

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

### Docker Container Setup for grpcurl

Source: https://www.dwellir.com/docs/sui/grpc-setup-grpcurl

Dockerfile configuration to install grpcurl and necessary utilities in an Alpine-based image.

```dockerfile
FROM alpine:latest

RUN apk add --no-cache curl jq bash

# Install grpcurl
RUN curl -sSL "https://github.com/fullstorydev/grpcurl/releases/download/v1.8.9/grpcurl_1.8.9_linux_x86_64.tar.gz" | tar -xz && \
    mv grpcurl /usr/local/bin/ && \
    chmod +x /usr/local/bin/grpcurl

# Copy scripts
COPY scripts/ /scripts/
RUN chmod +x /scripts/*.sh

CMD ["/bin/bash"]
```

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

### Successful system_syncState Response

Source: https://www.dwellir.com/docs/bittensor/system_syncState

Example of a successful JSON response containing the starting, current, and highest block numbers.

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "startingBlock": 900000,
    "currentBlock": 915000,
    "highestBlock": 930000
  }
}
```

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

### eth_getCode Implementation Examples

Source: https://www.dwellir.com/docs/base/eth_getCode

Examples demonstrating how to fetch contract bytecode using cURL, ethers.js, web3.py, and go-ethereum.

```bash
curl -X POST https://api-base-mainnet-archive.n.dwellir.com/YOUR_API_KEY \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getCode",
    "params": [
      "0x4200000000000000000000000000000000000006",
      "latest"
    ],
    "id": 1
  }'
```

```javascript
import { JsonRpcProvider } from 'ethers';

const provider = new JsonRpcProvider('https://api-base-mainnet-archive.n.dwellir.com/YOUR_API_KEY');

const address = '0x4200000000000000000000000000000000000006';
const code = await provider.getCode(address);

if (code === '0x') {
  console.log('Address is an EOA (externally owned account)');
} else {
  console.log('Address is a contract');
  console.log('Bytecode length:', code.length);
}

// Check if address is a contract
async function isContract(address) {
  const code = await provider.getCode(address);
  return code !== '0x';
}
```

```python
from web3 import Web3

w3 = Web3(Web3.HTTPProvider('https://api-base-mainnet-archive.n.dwellir.com/YOUR_API_KEY'))

address = '0x4200000000000000000000000000000000000006'
code = w3.eth.get_code(address)

if code == b'':
    print('Address is an EOA')
else:
    print('Address is a contract')
    print(f'Bytecode length: {len(code.hex())}')

# eth_getCode - Base RPC Method
def is_contract(address):
    code = w3.eth.get_code(address)
    return code != b''
```

```go
package main

import (
    "context"
    "fmt"
    "log"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/ethclient"
)

func main() {
    client, err := ethclient.Dial("https://api-base-mainnet-archive.n.dwellir.com/YOUR_API_KEY")
    if err != nil {
        log.Fatal(err)
    }

    address := common.HexToAddress("0x4200000000000000000000000000000000000006")
    code, err := client.CodeAt(context.Background(), address, nil)
    if err != nil {
        log.Fatal(err)
    }

    if len(code) == 0 {
        fmt.Println("Address is an EOA")
    } else {
        fmt.Printf("Contract bytecode length: %d\n", len(code))
    }
}
```

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

### Implementation Example in JavaScript

Source: https://www.dwellir.com/docs/linea/rollup_gasPrices

Demonstrates how to fetch gas prices and implement a monitoring class for Linea zkEVM.

```javascript
const response = await fetch('https://api-linea-mainnet-archive.n.dwellir.com/YOUR_API_KEY', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    method: 'rollup_gasPrices',
    params: [],
    id: 1
  })
});

const data = await response.json();
console.log('Gas Prices:', data.result);

// Advanced gas price monitoring for Linea zkEVM
class LineaGasPriceMonitor {
  constructor(rpcUrl) {
    this.rpcUrl = rpcUrl;
    this.priceHistory = [];
  }

  async getGasPrices() {
    const response = await fetch(this.rpcUrl, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        jsonrpc: '2.0',
        method: 'rollup_gasPrices',
        params: [],
        id: 1
      })
    });

    const data = await response.json();
    
    if (data.error) {
      throw new Error(`RPC Error: ${data.error.message}`);
    }

    return data.result;
  }

  async getCurrentPricing() {
    try {
      // Get rollup gas prices
      const rollupPrices = await this.getGasPrices();
      
      // Get standard gas price for comparison
      const standardGasResponse = await fetch(this.rpcUrl, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          jsonrpc: '2.0',
          method: 'eth_gasPrice',
          params: [],
          id: 1
        })
      });

      const standardGasData = await standardGasResponse.json();
      const standardGasPrice = parseInt(standardGasData.result, 16);

      return {
        timestamp: Date.now(),
        rollupPrices: rollupPrices,
        standardGasPrice: standardGasPrice,
        formattedPrices: this.formatPrices(rollupPrices, standardGasPrice)
      };
    } catch (error) {
      throw new Error(`Failed to get pricing: ${error.message}`);
    }
  }

  formatPrices(rollupPrices, standardGasPrice) {
    return {
      standardGasPrice: {
        wei: standardGasPrice,
        gwei: (standardGasPrice / 1e9).toFixed(2),
        eth: (standardGasPrice / 1e18).toFixed(8)
      },
      rollupData: rollupPrices // This will depend on actual response format
    };
  }

  async trackPriceHistory(duration = 3600000, interval = 60000) {
    // Track gas prices for specified duration (default 1 hour) at intervals (default 1 minute)
    const startTime = Date.now();
    const endTime = startTime + duration;

    console.log(`Starting price tracking for ${duration / 60000} minutes...`);

    while (Date.now() < endTime) {
      try {
        const pricing = await this.getCurrentPricing();
        this.priceHistory.push(pricing);
        
        console.log(`Price update: ${pricing.formattedPrices.standardGasPrice.gwei} gwei`);
        
        await new Promise(resolve => setTimeout(resolve, interval));
      } catch (error) {
        console.error('Price tracking error:', error.message);
        await new Promise(resolve => setTimeout(resolve, interval));
      }
    }

    return this.analyzePriceHistory();
  }

  analyzePriceHistory() {
    if (this.priceHistory.length === 0) {
      return { error: 'No price history available' };
    }

    const prices = this.priceHistory.map(p => p.standardGasPrice);
    const sortedPrices = [...prices].sort((a, b) => a - b);
```

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

### Go Implementation Example

Source: https://www.dwellir.com/docs/manta-pacific/eth_getStorageAt

Example using the go-ethereum client to retrieve storage data.

```go
package main

import (
    "context"
    "fmt"
    "log"
    "math/big"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/ethclient"
)

func main() {
    client, err := ethclient.Dial("https://api-manta-pacific-archive.n.dwellir.com/YOUR_API_KEY")
    if err != nil {
        log.Fatal(err)
    }

    address := common.HexToAddress("0x0Dc808adcE2099A9F62AA87D9670745AbA741746")
    slot := common.BigToHash(big.NewInt(0))

    value, err := client.StorageAt(context.Background(), address, slot, nil)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Storage at slot 0: 0x%x\n", value)
}
```

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

### Get Package via grpcurl

Source: https://www.dwellir.com/docs/sui/grpc/package/get-package

Examples of using grpcurl to query package information from the Dwellir Sui mainnet endpoint.

```bash
# Get the Sui Framework package (0x2)
    grpcurl \
      -H "x-api-key: YOUR_API_KEY" \
      -d '{
        "package_id": "0x0000000000000000000000000000000000000000000000000000000000000002"
      }' \
      api-sui-mainnet-full.n.dwellir.com:443 \
      sui.rpc.v2.MovePackageService/GetPackage

    # Get the Move Standard Library (0x1)
    grpcurl \
      -H "x-api-key: YOUR_API_KEY" \
      -d '{
        "package_id": "0x0000000000000000000000000000000000000000000000000000000000000001"
      }' \
      api-sui-mainnet-full.n.dwellir.com:443 \
      sui.rpc.v2.MovePackageService/GetPackage

    # Get DeepBook package
    grpcurl \
      -H "x-api-key: YOUR_API_KEY" \
      -d '{"package_id": "0xdee9"}' \
      api-sui-mainnet-full.n.dwellir.com:443 \
      sui.rpc.v2.MovePackageService/GetPackage
```

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

### StreamMiscEvents Request via grpcurl

Source: https://www.dwellir.com/docs/hyperliquid/stream_misc_events

Example command to initiate a stream of miscellaneous events starting from a specific block height.

```bash
grpcurl \
  -import-path content/docs/hyperliquid/grpc \
  -proto v2.proto \
  -H "x-api-key: ${DWELLIR_API_KEY}" \
  -d '{"block_height":"1058646974"}' \
  "${HYPERLIQUID_GRPC_ENDPOINT}" \
  hyperliquid_l1_gateway.v2.HyperliquidL1Gateway/StreamMiscEvents
```

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

### Initialize Go Module

Source: https://www.dwellir.com/docs/sui/grpc-setup-go

Create the project directory and initialize a new Go module.

```bash
# Create project directory
mkdir sui-grpc-go
cd sui-grpc-go

# Initialize Go module
go mod init github.com/yourusername/sui-grpc-go
```

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

### GET /v1/transactions

Source: https://www.dwellir.com/docs/aptos/transactions_list

Retrieves a list of transactions from the Aptos blockchain, with support for pagination using start version and limit parameters.

```APIDOC
## GET /v1/transactions

### Description
Retrieves a list of transactions from the Aptos blockchain. You can specify the starting version and the number of transactions to return.

### Method
GET

### Endpoint
https://api-aptos-mainnet.n.dwellir.com/{YOUR_API_KEY}/v1/transactions

### Parameters
#### Query Parameters
- **start** (integer) - Optional - The version number to start retrieving transactions from.
- **limit** (integer) - Optional - The maximum number of transactions to return.
```

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

### Go Implementation

Source: https://www.dwellir.com/docs/arbitrum/eth_maxPriorityFeePerGas

Example using the go-ethereum client to suggest gas tip cap.

```go
package main

import (
    "context"
    "fmt"
    "log"
    "math/big"

    "github.com/ethereum/go-ethereum/ethclient"
)

func main() {
    client, err := ethclient.Dial("https://api-arbitrum-mainnet-archive.n.dwellir.com/YOUR_API_KEY")
    if err != nil {
        log.Fatal(err)
    }

    tip, err := client.SuggestGasTipCap(context.Background())
    if err != nil {
        log.Fatal(err)
    }

    gwei := new(big.Float).Quo(new(big.Float).SetInt(tip), big.NewFloat(1e9))
    fmt.Printf("Arbitrum priority fee: %s Gwei\n", gwei.Text('f', 4))
}
```

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

### Get Account Bandwidth via cURL

Source: https://www.dwellir.com/docs/tron/wallet-getaccountnet

Use these examples to query bandwidth information using either base58 or hex address formats.

```bash
# Get bandwidth info with base58 address
    curl -X POST https://api-tron-mainnet.n.dwellir.com/YOUR_API_KEY/wallet/getaccountnet \
      -H "Content-Type: application/json" \
      -d '{
        "address": "TNPdqto8HiuMzoG7Vv9wyyYhWzCojLeHAF",
        "visible": true
      }'

    # Get bandwidth info with hex address
    curl -X POST https://api-tron-mainnet.n.dwellir.com/YOUR_API_KEY/wallet/getaccountnet \
      -H "Content-Type: application/json" \
      -d '{
        "address": "TNPdqto8HiuMzoG7Vv9wyyYhWzCojLeHAF"
      }'
```

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

### Implementation Examples for eth_getBalance

Source: https://www.dwellir.com/docs/centrifuge/eth_getBalance

Code examples demonstrating how to query account balances using cURL, JavaScript (ethers.js), Python (web3.py), and Go (go-ethereum).

```bash
curl -X POST https://api-centrifuge.n.dwellir.com/YOUR_API_KEY \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getBalance",
    "params": [
      "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
      "latest"
    ],
    "id": 1
  }'
```

```javascript
// Using ethers.js
import { JsonRpcProvider, formatEther } from 'ethers';

const provider = new JsonRpcProvider('https://api-centrifuge.n.dwellir.com/YOUR_API_KEY');

async function getBalance(address) {
  // Get balance in wei
  const balanceWei = await provider.getBalance(address);
  
  // Convert to ETH
  const balanceEth = formatEther(balanceWei);
  
  console.log(`Balance: ${balanceEth} ETH`);
  return balanceEth;
}

// Check multiple balances
async function getMultipleBalances(addresses) {
  const balances = await Promise.all(
    addresses.map(async (addr) => {
      const balance = await provider.getBalance(addr);
      return {
        address: addr,
        balance: formatEther(balance)
      };
    })
  );
  return balances;
}
```

```python
from web3 import Web3

# Connect to Ethereum
w3 = Web3(Web3.HTTPProvider('https://api-centrifuge.n.dwellir.com/YOUR_API_KEY'))

def get_balance(address):
    # Get balance in wei
    balance_wei = w3.eth.get_balance(address)
    
    # Convert to ETH
    balance_eth = w3.from_wei(balance_wei, 'ether')
    
    print(f"Balance: {balance_eth} ETH")
    return balance_eth

# Get balance at specific block
def get_historical_balance(address, block_number):
    balance_wei = w3.eth.get_balance(address, block_identifier=block_number)
    return w3.from_wei(balance_wei, 'ether')

# Monitor balance changes
def monitor_balance(address, interval=2):
    import time
    last_balance = 0
    
    while True:
        current_balance = w3.eth.get_balance(address)
        if current_balance != last_balance:
            change = current_balance - last_balance
            print(f"Balance changed: {w3.from_wei(change, 'ether')} ETH")
            last_balance = current_balance
        time.sleep(interval)
```

```go
package main

import (
    "context"
    "fmt"
    "log"
    "math/big"
    
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/ethclient"
)

func main() {
    client, err := ethclient.Dial("https://api-centrifuge.n.dwellir.com/YOUR_API_KEY")
    if err != nil {
        log.Fatal(err)
    }
    
    address := common.HexToAddress("0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045")
    
    // Get balance at latest block
    balance, err := client.BalanceAt(context.Background(), address, nil)
    if err != nil {
        log.Fatal(err)
    }
    
    // Convert wei to ETH
    ethValue := new(big.Float).Quo(
        new(big.Float).SetInt(balance),
        big.NewFloat(1e18),
    )
    
    fmt.Printf("Balance: %f ETH\n", ethValue)
}
```

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

### Fetch Transactions via cURL

Source: https://www.dwellir.com/docs/aptos/transactions_list

Retrieve recent transactions or transactions starting from a specific version using standard HTTP GET requests.

```bash
# Get the 25 most recent transactions
curl -X GET "https://api-aptos-mainnet.n.dwellir.com/YOUR_API_KEY/v1/transactions?limit=25" \
  -H "Accept: application/json"

# Get transactions starting from a specific version
curl -X GET "https://api-aptos-mainnet.n.dwellir.com/YOUR_API_KEY/v1/transactions?start=100000000&limit=100" \
  -H "Accept: application/json"
```

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

### eth_uninstallFilter Implementation Examples

Source: https://www.dwellir.com/docs/avalanche/eth_uninstallFilter

Examples demonstrating how to invoke eth_uninstallFilter using various tools and programming languages.

```bash
curl -X POST https://api-avalanche-mainnet-archive.n.dwellir.com/YOUR_API_KEY/ext/bc/C/rpc \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_uninstallFilter",
    "params": ["0x1"],
    "id": 1
  }'
```

```javascript
import { JsonRpcProvider } from 'ethers';

const provider = new JsonRpcProvider('https://api-avalanche-mainnet-archive.n.dwellir.com/YOUR_API_KEY/ext/bc/C/rpc');

// Create a filter first
const filterId = await provider.send('eth_newBlockFilter', []);
console.log('Created filter:', filterId);

// ... poll with eth_getFilterChanges ...

// Remove the filter when done
const removed = await provider.send('eth_uninstallFilter', [filterId]);
console.log('Filter removed:', removed);
```

```python
from web3 import Web3

w3 = Web3(Web3.HTTPProvider('https://api-avalanche-mainnet-archive.n.dwellir.com/YOUR_API_KEY/ext/bc/C/rpc'))

# eth_uninstallFilter - Avalanche RPC Method
filter_id = w3.eth.filter('latest').filter_id

# ... poll for changes ...

# Remove the filter when done
removed = w3.provider.make_request('eth_uninstallFilter', [filter_id])
print(f'Filter removed: {removed["result"]}')

# Using requests directly
import requests

response = requests.post(
    'https://api-avalanche-mainnet-archive.n.dwellir.com/YOUR_API_KEY/ext/bc/C/rpc',
    json={
        'jsonrpc': '2.0',
        'method': 'eth_uninstallFilter',
        'params': ['0x1'],
        'id': 1
    }
)
print(f'Removed: {response.json()["result"]}')
```

```go
package main

import (
    "context"
    "fmt"
    "log"

    "github.com/ethereum/go-ethereum/rpc"
)

func main() {
    client, err := rpc.Dial("https://api-avalanche-mainnet-archive.n.dwellir.com/YOUR_API_KEY/ext/bc/C/rpc")
    if err != nil {
        log.Fatal(err)
    }

    // Create a block filter
    var filterId string
    err = client.CallContext(context.Background(), &filterId, "eth_newBlockFilter")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Created filter: %s\n", filterId)

    // Remove the filter
    var removed bool
    err = client.CallContext(context.Background(), &removed, "eth_uninstallFilter", filterId)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Filter removed: %t\n", removed)
}
```

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

### GET /v1/accounts/{address}/transactions

Source: https://www.dwellir.com/docs/aptos/accounts_transactions

Retrieves a list of transactions for a specific account address, supporting pagination via limit and start parameters.

```APIDOC
## GET /v1/accounts/{address}/transactions

### Description
Retrieves the transaction history for a given account address. Supports limiting the number of results and paginating through the history using sequence numbers.

### Method
GET

### Endpoint
https://api-aptos-mainnet.n.dwellir.com/{YOUR_API_KEY}/v1/accounts/{address}/transactions

### Parameters
#### Path Parameters
- **address** (string) - Required - The account address to fetch transactions for.

#### Query Parameters
- **limit** (integer) - Optional - The maximum number of transactions to return.
- **start** (integer) - Optional - The sequence number to start fetching transactions from.
```

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

### eth_uninstallFilter Implementation Examples

Source: https://www.dwellir.com/docs/astar/eth_uninstallFilter

Examples of how to call eth_uninstallFilter using various programming languages and tools.

```bash
curl -X POST https://api-astar.n.dwellir.com/YOUR_API_KEY \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_uninstallFilter",
    "params": ["0x1"],
    "id": 1
  }'
```

```javascript
import { JsonRpcProvider } from 'ethers';

const provider = new JsonRpcProvider('https://api-astar.n.dwellir.com/YOUR_API_KEY');

// Create a filter first
const filterId = await provider.send('eth_newBlockFilter', []);
console.log('Created filter:', filterId);

// ... poll with eth_getFilterChanges ...

// Remove the filter when done
const removed = await provider.send('eth_uninstallFilter', [filterId]);
console.log('Filter removed:', removed);
```

```python
from web3 import Web3

w3 = Web3(Web3.HTTPProvider('https://api-astar.n.dwellir.com/YOUR_API_KEY'))

# eth_uninstallFilter - Astar RPC Method
filter_id = w3.eth.filter('latest').filter_id

# ... poll for changes ...

# Remove the filter when done
removed = w3.provider.make_request('eth_uninstallFilter', [filter_id])
print(f'Filter removed: {removed["result"]}')

# Using requests directly
import requests

response = requests.post(
    'https://api-astar.n.dwellir.com/YOUR_API_KEY',
    json={
        'jsonrpc': '2.0',
        'method': 'eth_uninstallFilter',
        'params': ['0x1'],
        'id': 1
    }
)
print(f'Removed: {response.json()["result"]}')
```

```go
package main

import (
    "context"
    "fmt"
    "log"

    "github.com/ethereum/go-ethereum/rpc"
)

func main() {
    client, err := rpc.Dial("https://api-astar.n.dwellir.com/YOUR_API_KEY")
    if err != nil {
        log.Fatal(err)
    }

    // Create a block filter
    var filterId string
    err = client.CallContext(context.Background(), &filterId, "eth_newBlockFilter")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Created filter: %s\n", filterId)

    // Remove the filter
    var removed bool
    err = client.CallContext(context.Background(), &removed, "eth_uninstallFilter", filterId)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Filter removed: %t\n", removed)
}
```

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

### TRON Client Usage and Monitoring Examples

Source: https://www.dwellir.com/docs/tron/wallet-getnowblock

Demonstrates fetching latest block info, network performance analysis, and event-based monitoring setup.

```python
if __name__ == "__main__":
    client = TronBlockClient('YOUR_API_KEY')
    
    try:
        # Get latest block info
        block_info = client.get_block_info()
        print(f"Latest block: #{block_info['block_number']}")
        print(f"Transactions: {block_info['transaction_count']}")
        print(f"Timestamp: {block_info['datetime']}")
        
        # Analyze network performance
        performance = client.analyze_network_performance()
        print(f"Network performance: {performance}")
        
        # Set up block monitoring
        monitor = TronBlockMonitor('YOUR_API_KEY')
        
        def on_new_block(block):
            print(f"📦 New block: #{block['block_number']} "
                  f"({block['transaction_count']} txs)")
        
        def on_transaction(tx):
            print(f"💸 New transaction: {tx['tx_id']} "
                  f"in block {tx['block_number']}")
        
        monitor.on('new_block', on_new_block)
        monitor.on('transaction', on_transaction)
        
        # Start monitoring (uncomment for continuous monitoring)
        # monitor.start()
        # time.sleep(30)  # Monitor for 30 seconds
        # monitor.stop()
        
        # Collect network statistics
        stats_collector = TronNetworkStats('YOUR_API_KEY')
        # stats = stats_collector.collect_stats(1)  # Collect for 1 minute
        # print(f"Network statistics: {stats}")
        
    except Exception as e:
        print(f"Error: {e}")
```

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

### Get TRON block by hash using cURL

Source: https://www.dwellir.com/docs/tron/wallet-getblockbyid

Examples for retrieving block data with and without full transaction details using the POST method.

```bash
# Get block by hash ID
    curl -X POST https://api-tron-mainnet.n.dwellir.com/YOUR_API_KEY/wallet/getblockbyid \
      -H "Content-Type: application/json" \
      -d '{
        "value": "0000000003787ac74d9bb8f8c9c59ac3f3e3b9b8c9e3e8f9c8d7e8f9c8d7e8f9"
      }'

    # Get block with full transaction details
    curl -X POST https://api-tron-mainnet.n.dwellir.com/YOUR_API_KEY/wallet/getblockbyid \
      -H "Content-Type: application/json" \
      -d '{
        "value": "0000000003787ac74d9bb8f8c9c59ac3f3e3b9b8c9e3e8f9c8d7e8f9c8d7e8f9",
        "detail": true
      }'
```
Tokens:
Raw