Nano Node RPC

curl -d '{ "action": "version" }' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
action: "version"
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = { action: "version" }

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn version(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "version");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def version(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = { action: 'version' }

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function version($title) {
  $url = 'https://rpc.nano.to';
  $data = array({ action: 'version' });
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> version(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{ action: "version" }),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func version(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{"action": "version"}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> version(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  action = "version"
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db 'action: version', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{
  "action": "account_info",
  "account": "@development"
}' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
  "action": "account_info",
  "account": "@development"
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = {
  "action": "account_info",
  "account": "@development"
}

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn account_info(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "account_info");
    data.insert("account", "@development");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def account_info(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = {
  action: 'account_info',
  account: '@development'
}

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function account_info($title) {
  $url = 'https://rpc.nano.to';
  $data = array({
  action: 'account_info',
  account: '@development'
});
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> account_info(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{
  "action": "account_info",
  "account": "@development"
}),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func account_info(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{
  action  "account_info",
  account  "@development"
}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> account_info(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  {
  action = "account_info",
  account = "@development"
}
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db '{
  action: account_info,
  account: @development
}', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{
  "action": "account_history",
  "account": "@faucet",
  "count": "1"
}' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
  "action": "account_history",
  "account": "@faucet",
  "count": "1"
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = {
  "action": "account_history",
  "account": "@faucet",
  "count": "1"
}

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn account_history(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "account_history");
    data.insert("account", "@faucet");
    data.insert("count", "1");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def account_history(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = {
  action: 'account_history',
  account: '@faucet',
  count: '1'
}

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function account_history($title) {
  $url = 'https://rpc.nano.to';
  $data = array({
  action: 'account_history',
  account: '@faucet',
  count: '1'
});
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> account_history(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{
  "action": "account_history",
  "account": "@faucet",
  "count": "1"
}),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func account_history(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{
  action  "account_history",
  account  "@faucet",
  count  "1"
}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> account_history(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  {
  action = "account_history",
  account = "@faucet",
  count = "1"
}
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db '{
  action: account_history,
  account: @faucet,
  count: 1
}', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{
  "action": "receivable",
  "account": "@faucet",
  "count": "5"
}' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
  "action": "receivable",
  "account": "@faucet",
  "count": "5"
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = {
  "action": "receivable",
  "account": "@faucet",
  "count": "5"
}

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn receivable(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "receivable");
    data.insert("account", "@faucet");
    data.insert("count", "5");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def receivable(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = {
  action: 'receivable',
  account: '@faucet',
  count: '5'
}

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function receivable($title) {
  $url = 'https://rpc.nano.to';
  $data = array({
  action: 'receivable',
  account: '@faucet',
  count: '5'
});
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> receivable(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{
  "action": "receivable",
  "account": "@faucet",
  "count": "5"
}),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func receivable(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{
  action  "receivable",
  account  "@faucet",
  count  "5"
}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> receivable(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  {
  action = "receivable",
  account = "@faucet",
  count = "5"
}
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db '{
  action: receivable,
  account: @faucet,
  count: 5
}', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{
  "action": "account_balance",
  "account": "@development"
}' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
  "action": "account_balance",
  "account": "@development"
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = {
  "action": "account_balance",
  "account": "@development"
}

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn account_balance(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "account_balance");
    data.insert("account", "@development");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def account_balance(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = {
  action: 'account_balance',
  account: '@development'
}

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function account_balance($title) {
  $url = 'https://rpc.nano.to';
  $data = array({
  action: 'account_balance',
  account: '@development'
});
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> account_balance(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{
  "action": "account_balance",
  "account": "@development"
}),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func account_balance(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{
  action  "account_balance",
  account  "@development"
}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> account_balance(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  {
  action = "account_balance",
  account = "@development"
}
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db '{
  action: account_balance,
  account: @development
}', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{
  "action": "accounts_balances",
  "accounts": [
    "@development",
    "nano_3i1aq1cchnmbn9x5rsbap8b15akfh7wj7pwskuzi7ahz8oq6cobd99d4r3b7",
    "@faucet"
  ]
}' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
  "action": "accounts_balances",
  "accounts": [
    "@development",
    "nano_3i1aq1cchnmbn9x5rsbap8b15akfh7wj7pwskuzi7ahz8oq6cobd99d4r3b7",
    "@faucet"
  ]
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = {
  "action": "accounts_balances",
  "accounts": [
    "@development",
    "nano_3i1aq1cchnmbn9x5rsbap8b15akfh7wj7pwskuzi7ahz8oq6cobd99d4r3b7",
    "@faucet"
  ]
}

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn accounts_balances(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "accounts_balances");
    data.insert("accounts", "@development,nano_3i1aq1cchnmbn9x5rsbap8b15akfh7wj7pwskuzi7ahz8oq6cobd99d4r3b7,@faucet");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def accounts_balances(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = {
  action: 'accounts_balances',
  accounts: [
    '@development',
    'nano_3i1aq1cchnmbn9x5rsbap8b15akfh7wj7pwskuzi7ahz8oq6cobd99d4r3b7',
    '@faucet'
  ]
}

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function accounts_balances($title) {
  $url = 'https://rpc.nano.to';
  $data = array({
  action: 'accounts_balances',
  accounts: [
    '@development',
    'nano_3i1aq1cchnmbn9x5rsbap8b15akfh7wj7pwskuzi7ahz8oq6cobd99d4r3b7',
    '@faucet'
  ]
});
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> accounts_balances(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{
  "action": "accounts_balances",
  "accounts": [
    "@development",
    "nano_3i1aq1cchnmbn9x5rsbap8b15akfh7wj7pwskuzi7ahz8oq6cobd99d4r3b7",
    "@faucet"
  ]
}),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func accounts_balances(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{
  action  "accounts_balances",
  accounts  [
    "@development",
    "nano_3i1aq1cchnmbn9x5rsbap8b15akfh7wj7pwskuzi7ahz8oq6cobd99d4r3b7",
    "@faucet"
  ]
}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> accounts_balances(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  {
  action = "accounts_balances",
  accounts = [
    "@development",
    "nano_3i1aq1cchnmbn9x5rsbap8b15akfh7wj7pwskuzi7ahz8oq6cobd99d4r3b7",
    "@faucet"
  ]
}
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db '{
  action: accounts_balances,
  accounts: [
    @development,
    nano_3i1aq1cchnmbn9x5rsbap8b15akfh7wj7pwskuzi7ahz8oq6cobd99d4r3b7,
    @faucet
  ]
}', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{
  "action": "accounts_receivable",
  "accounts": [
    "nano_1111111111111111111111111111111111111111111111111117353trpda",
    "@development"
  ]
}' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
  "action": "accounts_receivable",
  "accounts": [
    "nano_1111111111111111111111111111111111111111111111111117353trpda",
    "@development"
  ]
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = {
  "action": "accounts_receivable",
  "accounts": [
    "nano_1111111111111111111111111111111111111111111111111117353trpda",
    "@development"
  ]
}

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn accounts_receivable(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "accounts_receivable");
    data.insert("accounts", "nano_1111111111111111111111111111111111111111111111111117353trpda,@development");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def accounts_receivable(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = {
  action: 'accounts_receivable',
  accounts: [
    'nano_1111111111111111111111111111111111111111111111111117353trpda',
    '@development'
  ]
}

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function accounts_receivable($title) {
  $url = 'https://rpc.nano.to';
  $data = array({
  action: 'accounts_receivable',
  accounts: [
    'nano_1111111111111111111111111111111111111111111111111117353trpda',
    '@development'
  ]
});
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> accounts_receivable(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{
  "action": "accounts_receivable",
  "accounts": [
    "nano_1111111111111111111111111111111111111111111111111117353trpda",
    "@development"
  ]
}),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func accounts_receivable(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{
  action  "accounts_receivable",
  accounts  [
    "nano_1111111111111111111111111111111111111111111111111117353trpda",
    "@development"
  ]
}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> accounts_receivable(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  {
  action = "accounts_receivable",
  accounts = [
    "nano_1111111111111111111111111111111111111111111111111117353trpda",
    "@development"
  ]
}
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db '{
  action: accounts_receivable,
  accounts: [
    nano_1111111111111111111111111111111111111111111111111117353trpda,
    @development
  ]
}', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{
  "action": "block_info",
  "hash": "B5E0BE6DAB75740A...06CC4EC7A548F4AFD37A"
}' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
  "action": "block_info",
  "hash": "B5E0BE6DAB75740A...06CC4EC7A548F4AFD37A"
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = {
  "action": "block_info",
  "hash": "B5E0BE6DAB75740A...06CC4EC7A548F4AFD37A"
}

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn block_info(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "block_info");
    data.insert("hash", "B5E0BE6DAB75740A...06CC4EC7A548F4AFD37A");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def block_info(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = {
  action: 'block_info',
  hash: 'B5E0BE6DAB75740A...06CC4EC7A548F4AFD37A'
}

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function block_info($title) {
  $url = 'https://rpc.nano.to';
  $data = array({
  action: 'block_info',
  hash: 'B5E0BE6DAB75740A...06CC4EC7A548F4AFD37A'
});
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> block_info(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{
  "action": "block_info",
  "hash": "B5E0BE6DAB75740A...06CC4EC7A548F4AFD37A"
}),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func block_info(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{
  action  "block_info",
  hash  "B5E0BE6DAB75740A...06CC4EC7A548F4AFD37A"
}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> block_info(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  {
  action = "block_info",
  hash = "B5E0BE6DAB75740A...06CC4EC7A548F4AFD37A"
}
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db '{
  action: block_info,
  hash: B5E0BE6DAB75740A...06CC4EC7A548F4AFD37A
}', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{
  "action": "blocks_info",
  "source": "true",
  "receive_hash": "true",
  "hashes": [
    "E2FB233EF4554077A7BF1AA85851D5BF0B36965D2B0FB504B2BC778AB89917D3",
    "67D9F9F03566D22926159193BD5BDE549FBE8308807C666BCCD3CEA098FBF49D"
  ]
}' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
  "action": "blocks_info",
  "source": "true",
  "receive_hash": "true",
  "hashes": [
    "E2FB233EF4554077A7BF1AA85851D5BF0B36965D2B0FB504B2BC778AB89917D3",
    "67D9F9F03566D22926159193BD5BDE549FBE8308807C666BCCD3CEA098FBF49D"
  ]
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = {
  "action": "blocks_info",
  "source": "true",
  "receive_hash": "true",
  "hashes": [
    "E2FB233EF4554077A7BF1AA85851D5BF0B36965D2B0FB504B2BC778AB89917D3",
    "67D9F9F03566D22926159193BD5BDE549FBE8308807C666BCCD3CEA098FBF49D"
  ]
}

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn blocks_info(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "blocks_info");
    data.insert("source", "true");
    data.insert("receive_hash", "true");
    data.insert("hashes", "E2FB233EF4554077A7BF1AA85851D5BF0B36965D2B0FB504B2BC778AB89917D3,67D9F9F03566D22926159193BD5BDE549FBE8308807C666BCCD3CEA098FBF49D");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def blocks_info(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = {
  action: 'blocks_info',
  source: 'true',
  receive_hash: 'true',
  hashes: [
    'E2FB233EF4554077A7BF1AA85851D5BF0B36965D2B0FB504B2BC778AB89917D3',
    '67D9F9F03566D22926159193BD5BDE549FBE8308807C666BCCD3CEA098FBF49D'
  ]
}

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function blocks_info($title) {
  $url = 'https://rpc.nano.to';
  $data = array({
  action: 'blocks_info',
  source: 'true',
  receive_hash: 'true',
  hashes: [
    'E2FB233EF4554077A7BF1AA85851D5BF0B36965D2B0FB504B2BC778AB89917D3',
    '67D9F9F03566D22926159193BD5BDE549FBE8308807C666BCCD3CEA098FBF49D'
  ]
});
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> blocks_info(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{
  "action": "blocks_info",
  "source": "true",
  "receive_hash": "true",
  "hashes": [
    "E2FB233EF4554077A7BF1AA85851D5BF0B36965D2B0FB504B2BC778AB89917D3",
    "67D9F9F03566D22926159193BD5BDE549FBE8308807C666BCCD3CEA098FBF49D"
  ]
}),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func blocks_info(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{
  action  "blocks_info",
  source  "true",
  receive_hash  "true",
  hashes  [
    "E2FB233EF4554077A7BF1AA85851D5BF0B36965D2B0FB504B2BC778AB89917D3",
    "67D9F9F03566D22926159193BD5BDE549FBE8308807C666BCCD3CEA098FBF49D"
  ]
}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> blocks_info(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  {
  action = "blocks_info",
  source = "true",
  receive_hash = "true",
  hashes = [
    "E2FB233EF4554077A7BF1AA85851D5BF0B36965D2B0FB504B2BC778AB89917D3",
    "67D9F9F03566D22926159193BD5BDE549FBE8308807C666BCCD3CEA098FBF49D"
  ]
}
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db '{
  action: blocks_info,
  source: true,
  receive_hash: true,
  hashes: [
    E2FB233EF4554077A7BF1AA85851D5BF0B36965D2B0FB504B2BC778AB89917D3,
    67D9F9F03566D22926159193BD5BDE549FBE8308807C666BCCD3CEA098FBF49D
  ]
}', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{
  "action": "find_block",
  "address": "@bank",
  "amount": "0.00755"
}' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
  "action": "find_block",
  "address": "@bank",
  "amount": "0.00755"
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = {
  "action": "find_block",
  "address": "@bank",
  "amount": "0.00755"
}

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn find_block(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "find_block");
    data.insert("address", "@bank");
    data.insert("amount", "0.00755");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def find_block(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = {
  action: 'find_block',
  address: '@bank',
  amount: '0.00755'
}

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function find_block($title) {
  $url = 'https://rpc.nano.to';
  $data = array({
  action: 'find_block',
  address: '@bank',
  amount: '0.00755'
});
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> find_block(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{
  "action": "find_block",
  "address": "@bank",
  "amount": "0.00755"
}),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func find_block(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{
  action  "find_block",
  address  "@bank",
  amount  "0.00755"
}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> find_block(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  {
  action = "find_block",
  address = "@bank",
  amount = "0.00755"
}
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db '{
  action: find_block,
  address: @bank,
  amount: 0.00755
}', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{ "action": "block_sign" }' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
action: "block_sign"
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = { action: "block_sign" }

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn block_sign(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "block_sign");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def block_sign(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = { action: 'block_sign' }

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function block_sign($title) {
  $url = 'https://rpc.nano.to';
  $data = array({ action: 'block_sign' });
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> block_sign(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{ action: "block_sign" }),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func block_sign(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{"action": "block_sign"}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> block_sign(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  action = "block_sign"
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db 'action: block_sign', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{
  "action": "process",
  "json_block": "true",
  "subtype": "send",
  "block": {
    "type": "state",
    "account": "nano_1qato4k7z3spc8gq1zyd8xeqfbzsoxwo36a45ozbrxcatut7up8ohyardu1z",
    "previous": "6CDDA48608C7843A...EAC23E7F33F2E6A6766",
    "representative": "nano_3pczxuorp48td8645bs3m6c3xotxd3idskrenmi65rbrga5zmkemzhwkaznh",
    "balance": "40200000001000000000000000000000000",
    "link": "87434F8041869A0...7D7A3FD0CCC2358FD6F9",
    "link_as_account": "nano_33t5by1653nt196hfwm5q3wq7oxtaix97r7bhox5zn8eratrzoqsny49ftsd",
    "signature": "A5DB164F6B81648533900C3...ED4DCBF8EF2539EB2467F07",
    "work": "000bc55b014e807d"
  }
}' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
  "action": "process",
  "json_block": "true",
  "subtype": "send",
  "block": {
    "type": "state",
    "account": "nano_1qato4k7z3spc8gq1zyd8xeqfbzsoxwo36a45ozbrxcatut7up8ohyardu1z",
    "previous": "6CDDA48608C7843A...EAC23E7F33F2E6A6766",
    "representative": "nano_3pczxuorp48td8645bs3m6c3xotxd3idskrenmi65rbrga5zmkemzhwkaznh",
    "balance": "40200000001000000000000000000000000",
    "link": "87434F8041869A0...7D7A3FD0CCC2358FD6F9",
    "link_as_account": "nano_33t5by1653nt196hfwm5q3wq7oxtaix97r7bhox5zn8eratrzoqsny49ftsd",
    "signature": "A5DB164F6B81648533900C3...ED4DCBF8EF2539EB2467F07",
    "work": "000bc55b014e807d"
  }
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = {
  "action": "process",
  "json_block": "true",
  "subtype": "send",
  "block": {
    "type": "state",
    "account": "nano_1qato4k7z3spc8gq1zyd8xeqfbzsoxwo36a45ozbrxcatut7up8ohyardu1z",
    "previous": "6CDDA48608C7843A...EAC23E7F33F2E6A6766",
    "representative": "nano_3pczxuorp48td8645bs3m6c3xotxd3idskrenmi65rbrga5zmkemzhwkaznh",
    "balance": "40200000001000000000000000000000000",
    "link": "87434F8041869A0...7D7A3FD0CCC2358FD6F9",
    "link_as_account": "nano_33t5by1653nt196hfwm5q3wq7oxtaix97r7bhox5zn8eratrzoqsny49ftsd",
    "signature": "A5DB164F6B81648533900C3...ED4DCBF8EF2539EB2467F07",
    "work": "000bc55b014e807d"
  }
}

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn process(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "process");
    data.insert("action", "process");
    data.insert("json_block", "true");
    data.insert("subtype", "send");
    data.insert("block", "[object Object]");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def process(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = {
  action: 'process',
  json_block: 'true',
  subtype: 'send',
  block: {
    type: 'state',
    account: 'nano_1qato4k7z3spc8gq1zyd8xeqfbzsoxwo36a45ozbrxcatut7up8ohyardu1z',
    previous: '6CDDA48608C7843A...EAC23E7F33F2E6A6766',
    representative: 'nano_3pczxuorp48td8645bs3m6c3xotxd3idskrenmi65rbrga5zmkemzhwkaznh',
    balance: '40200000001000000000000000000000000',
    link: '87434F8041869A0...7D7A3FD0CCC2358FD6F9',
    link_as_account: 'nano_33t5by1653nt196hfwm5q3wq7oxtaix97r7bhox5zn8eratrzoqsny49ftsd',
    signature: 'A5DB164F6B81648533900C3...ED4DCBF8EF2539EB2467F07',
    work: '000bc55b014e807d'
  }
}

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function process($title) {
  $url = 'https://rpc.nano.to';
  $data = array({
  action: 'process',
  json_block: 'true',
  subtype: 'send',
  block: {
    type: 'state',
    account: 'nano_1qato4k7z3spc8gq1zyd8xeqfbzsoxwo36a45ozbrxcatut7up8ohyardu1z',
    previous: '6CDDA48608C7843A...EAC23E7F33F2E6A6766',
    representative: 'nano_3pczxuorp48td8645bs3m6c3xotxd3idskrenmi65rbrga5zmkemzhwkaznh',
    balance: '40200000001000000000000000000000000',
    link: '87434F8041869A0...7D7A3FD0CCC2358FD6F9',
    link_as_account: 'nano_33t5by1653nt196hfwm5q3wq7oxtaix97r7bhox5zn8eratrzoqsny49ftsd',
    signature: 'A5DB164F6B81648533900C3...ED4DCBF8EF2539EB2467F07',
    work: '000bc55b014e807d'
  }
});
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> process(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{
  "action": "process",
  "json_block": "true",
  "subtype": "send",
  "block": {
    "type": "state",
    "account": "nano_1qato4k7z3spc8gq1zyd8xeqfbzsoxwo36a45ozbrxcatut7up8ohyardu1z",
    "previous": "6CDDA48608C7843A...EAC23E7F33F2E6A6766",
    "representative": "nano_3pczxuorp48td8645bs3m6c3xotxd3idskrenmi65rbrga5zmkemzhwkaznh",
    "balance": "40200000001000000000000000000000000",
    "link": "87434F8041869A0...7D7A3FD0CCC2358FD6F9",
    "link_as_account": "nano_33t5by1653nt196hfwm5q3wq7oxtaix97r7bhox5zn8eratrzoqsny49ftsd",
    "signature": "A5DB164F6B81648533900C3...ED4DCBF8EF2539EB2467F07",
    "work": "000bc55b014e807d"
  }
}),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func process(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{
  action  "process",
  json_block  "true",
  subtype  "send",
  block  {
    type  "state",
    account  "nano_1qato4k7z3spc8gq1zyd8xeqfbzsoxwo36a45ozbrxcatut7up8ohyardu1z",
    previous  "6CDDA48608C7843A...EAC23E7F33F2E6A6766",
    representative  "nano_3pczxuorp48td8645bs3m6c3xotxd3idskrenmi65rbrga5zmkemzhwkaznh",
    balance  "40200000001000000000000000000000000",
    link  "87434F8041869A0...7D7A3FD0CCC2358FD6F9",
    link_as_account  "nano_33t5by1653nt196hfwm5q3wq7oxtaix97r7bhox5zn8eratrzoqsny49ftsd",
    signature  "A5DB164F6B81648533900C3...ED4DCBF8EF2539EB2467F07",
    work  "000bc55b014e807d"
  }
}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> process(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  {
  action = "process",
  json_block = "true",
  subtype = "send",
  block = {
    type = "state",
    account = "nano_1qato4k7z3spc8gq1zyd8xeqfbzsoxwo36a45ozbrxcatut7up8ohyardu1z",
    previous = "6CDDA48608C7843A...EAC23E7F33F2E6A6766",
    representative = "nano_3pczxuorp48td8645bs3m6c3xotxd3idskrenmi65rbrga5zmkemzhwkaznh",
    balance = "40200000001000000000000000000000000",
    link = "87434F8041869A0...7D7A3FD0CCC2358FD6F9",
    link_as_account = "nano_33t5by1653nt196hfwm5q3wq7oxtaix97r7bhox5zn8eratrzoqsny49ftsd",
    signature = "A5DB164F6B81648533900C3...ED4DCBF8EF2539EB2467F07",
    work = "000bc55b014e807d"
  }
}
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db '{
  action: process,
  json_block: true,
  subtype: send,
  block: {
    type: state,
    account: nano_1qato4k7z3spc8gq1zyd8xeqfbzsoxwo36a45ozbrxcatut7up8ohyardu1z,
    previous: 6CDDA48608C7843A...EAC23E7F33F2E6A6766,
    representative: nano_3pczxuorp48td8645bs3m6c3xotxd3idskrenmi65rbrga5zmkemzhwkaznh,
    balance: 40200000001000000000000000000000000,
    link: 87434F8041869A0...7D7A3FD0CCC2358FD6F9,
    link_as_account: nano_33t5by1653nt196hfwm5q3wq7oxtaix97r7bhox5zn8eratrzoqsny49ftsd,
    signature: A5DB164F6B81648533900C3...ED4DCBF8EF2539EB2467F07,
    work: 000bc55b014e807d
  }
}', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{
  "action": "work_generate",
  "hash": ":FRONTIER",
  "key": "RPC-API-KEY"
}' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
  "action": "work_generate",
  "hash": ":FRONTIER",
  "key": "RPC-API-KEY"
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = {
  "action": "work_generate",
  "hash": ":FRONTIER",
  "key": "RPC-API-KEY"
}

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn work_generate(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "work_generate");
    data.insert("hash", ":FRONTIER");
    data.insert("key", "RPC-API-KEY");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def work_generate(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = {
  action: 'work_generate',
  hash: ':FRONTIER',
  key: 'RPC-API-KEY'
}

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function work_generate($title) {
  $url = 'https://rpc.nano.to';
  $data = array({
  action: 'work_generate',
  hash: ':FRONTIER',
  key: 'RPC-API-KEY'
});
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> work_generate(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{
  "action": "work_generate",
  "hash": ":FRONTIER",
  "key": "RPC-API-KEY"
}),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func work_generate(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{
  action  "work_generate",
  hash  " FRONTIER",
  key  "RPC-API-KEY"
}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> work_generate(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  {
  action = "work_generate",
  hash = " FRONTIER",
  key = "RPC-API-KEY"
}
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db '{
  action: work_generate,
  hash: :FRONTIER,
  key: RPC-API-KEY
}', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{ "action": "block_count" }' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
action: "block_count"
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = { action: "block_count" }

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn block_count(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "block_count");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def block_count(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = { action: 'block_count' }

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function block_count($title) {
  $url = 'https://rpc.nano.to';
  $data = array({ action: 'block_count' });
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> block_count(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{ action: "block_count" }),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func block_count(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{"action": "block_count"}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> block_count(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  action = "block_count"
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db 'action: block_count', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{
  "action": "account_key",
  "account": "@faucet"
}' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
  "action": "account_key",
  "account": "@faucet"
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = {
  "action": "account_key",
  "account": "@faucet"
}

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn account_key(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "account_key");
    data.insert("account", "@faucet");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def account_key(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = {
  action: 'account_key',
  account: '@faucet'
}

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function account_key($title) {
  $url = 'https://rpc.nano.to';
  $data = array({
  action: 'account_key',
  account: '@faucet'
});
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> account_key(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{
  "action": "account_key",
  "account": "@faucet"
}),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func account_key(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{
  action  "account_key",
  account  "@faucet"
}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> account_key(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  {
  action = "account_key",
  account = "@faucet"
}
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db '{
  action: account_key,
  account: @faucet
}', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{
  "action": "price",
  "currency": "EUR"
}' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
  "action": "price",
  "currency": "EUR"
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = {
  "action": "price",
  "currency": "EUR"
}

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn price(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "price");
    data.insert("currency", "EUR");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def price(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = {
  action: 'price',
  currency: 'EUR'
}

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function price($title) {
  $url = 'https://rpc.nano.to';
  $data = array({
  action: 'price',
  currency: 'EUR'
});
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> price(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{
  "action": "price",
  "currency": "EUR"
}),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func price(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{
  action  "price",
  currency  "EUR"
}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> price(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  {
  action = "price",
  currency = "EUR"
}
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db '{
  action: price,
  currency: EUR
}', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{ "action": "reps" }' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
action: "reps"
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = { action: "reps" }

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn reps(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "reps");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def reps(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = { action: 'reps' }

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function reps($title) {
  $url = 'https://rpc.nano.to';
  $data = array({ action: 'reps' });
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> reps(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{ action: "reps" }),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func reps(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{"action": "reps"}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> reps(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  action = "reps"
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db 'action: reps', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{
  "action": "rep_info",
  "account": "nano_1jtx5p8141zjtukz4msp1x93st7nh475f74odj8673qqm96xczmtcnanos1o"
}' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
  "action": "rep_info",
  "account": "nano_1jtx5p8141zjtukz4msp1x93st7nh475f74odj8673qqm96xczmtcnanos1o"
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = {
  "action": "rep_info",
  "account": "nano_1jtx5p8141zjtukz4msp1x93st7nh475f74odj8673qqm96xczmtcnanos1o"
}

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn rep_info(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "rep_info");
    data.insert("account", "nano_1jtx5p8141zjtukz4msp1x93st7nh475f74odj8673qqm96xczmtcnanos1o");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def rep_info(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = {
  action: 'rep_info',
  account: 'nano_1jtx5p8141zjtukz4msp1x93st7nh475f74odj8673qqm96xczmtcnanos1o'
}

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function rep_info($title) {
  $url = 'https://rpc.nano.to';
  $data = array({
  action: 'rep_info',
  account: 'nano_1jtx5p8141zjtukz4msp1x93st7nh475f74odj8673qqm96xczmtcnanos1o'
});
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> rep_info(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{
  "action": "rep_info",
  "account": "nano_1jtx5p8141zjtukz4msp1x93st7nh475f74odj8673qqm96xczmtcnanos1o"
}),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func rep_info(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{
  action  "rep_info",
  account  "nano_1jtx5p8141zjtukz4msp1x93st7nh475f74odj8673qqm96xczmtcnanos1o"
}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> rep_info(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  {
  action = "rep_info",
  account = "nano_1jtx5p8141zjtukz4msp1x93st7nh475f74odj8673qqm96xczmtcnanos1o"
}
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db '{
  action: rep_info,
  account: nano_1jtx5p8141zjtukz4msp1x93st7nh475f74odj8673qqm96xczmtcnanos1o
}', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{
  "action": "nano_to_raw",
  "amount": "420.69"
}' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
  "action": "nano_to_raw",
  "amount": "420.69"
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = {
  "action": "nano_to_raw",
  "amount": "420.69"
}

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn nano_to_raw(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "nano_to_raw");
    data.insert("amount", "420.69");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def nano_to_raw(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = {
  action: 'nano_to_raw',
  amount: '420.69'
}

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function nano_to_raw($title) {
  $url = 'https://rpc.nano.to';
  $data = array({
  action: 'nano_to_raw',
  amount: '420.69'
});
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> nano_to_raw(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{
  "action": "nano_to_raw",
  "amount": "420.69"
}),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func nano_to_raw(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{
  action  "nano_to_raw",
  amount  "420.69"
}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> nano_to_raw(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  {
  action = "nano_to_raw",
  amount = "420.69"
}
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db '{
  action: nano_to_raw,
  amount: 420.69
}', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{
  "action": "raw_to_nano",
  "amount": "420690000000000000000000000000000"
}' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
  "action": "raw_to_nano",
  "amount": "420690000000000000000000000000000"
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = {
  "action": "raw_to_nano",
  "amount": "420690000000000000000000000000000"
}

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn raw_to_nano(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "raw_to_nano");
    data.insert("amount", "420690000000000000000000000000000");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def raw_to_nano(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = {
  action: 'raw_to_nano',
  amount: '420690000000000000000000000000000'
}

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function raw_to_nano($title) {
  $url = 'https://rpc.nano.to';
  $data = array({
  action: 'raw_to_nano',
  amount: '420690000000000000000000000000000'
});
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> raw_to_nano(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{
  "action": "raw_to_nano",
  "amount": "420690000000000000000000000000000"
}),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func raw_to_nano(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{
  action  "raw_to_nano",
  amount  "420690000000000000000000000000000"
}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> raw_to_nano(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  {
  action = "raw_to_nano",
  amount = "420690000000000000000000000000000"
}
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db '{
  action: raw_to_nano,
  amount: 420690000000000000000000000000000
}', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{
  "action": "known"
}' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
  "action": "known"
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = {
  "action": "known"
}

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn known(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "known");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def known(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = {
  action: 'known'
}

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function known($title) {
  $url = 'https://rpc.nano.to';
  $data = array({
  action: 'known'
});
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> known(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{
  "action": "known"
}),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func known(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{
  action  "known"
}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> known(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  {
  action = "known"
}
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db '{
  action: known
}', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{
  "action": "get_name",
  "name": "NanoBull"
}' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
  "action": "get_name",
  "name": "NanoBull"
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = {
  "action": "get_name",
  "name": "NanoBull"
}

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn get_name(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "get_name");
    data.insert("name", "NanoBull");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def get_name(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = {
  action: 'get_name',
  name: 'NanoBull'
}

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function get_name($title) {
  $url = 'https://rpc.nano.to';
  $data = array({
  action: 'get_name',
  name: 'NanoBull'
});
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> get_name(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{
  "action": "get_name",
  "name": "NanoBull"
}),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func get_name(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{
  action  "get_name",
  name  "NanoBull"
}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> get_name(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  {
  action = "get_name",
  name = "NanoBull"
}
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db '{
  action: get_name,
  name: NanoBull
}', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{
  "action": "update_name",
  "name": "NanoBull"
}' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
  "action": "update_name",
  "name": "NanoBull"
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = {
  "action": "update_name",
  "name": "NanoBull"
}

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn update_name(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "update_name");
    data.insert("name", "NanoBull");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def update_name(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = {
  action: 'update_name',
  name: 'NanoBull'
}

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function update_name($title) {
  $url = 'https://rpc.nano.to';
  $data = array({
  action: 'update_name',
  name: 'NanoBull'
});
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> update_name(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{
  "action": "update_name",
  "name": "NanoBull"
}),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func update_name(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{
  action  "update_name",
  name  "NanoBull"
}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> update_name(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  {
  action = "update_name",
  name = "NanoBull"
}
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db '{
  action: update_name,
  name: NanoBull
}', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{
  "action": "checkout",
  "title": "Nano Bird Feeder",
  "notify": "[email protected]",
  "webhook": "https://example/webhook/secret",
  "address": "YOUR_ADDRESS",
  "amount": "0.133",
  "metadata": {
    "secret": "joe-doe"
  }
}' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
  "action": "checkout",
  "title": "Nano Bird Feeder",
  "notify": "[email protected]",
  "webhook": "https://example/webhook/secret",
  "address": "YOUR_ADDRESS",
  "amount": "0.133",
  "metadata": {
    "secret": "joe-doe"
  }
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = {
  "action": "checkout",
  "title": "Nano Bird Feeder",
  "notify": "[email protected]",
  "webhook": "https://example/webhook/secret",
  "address": "YOUR_ADDRESS",
  "amount": "0.133",
  "metadata": {
    "secret": "joe-doe"
  }
}

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn checkout(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "checkout");
    data.insert("title", "Nano Bird Feeder");
    data.insert("notify", "[email protected]");
    data.insert("webhook", "https://example/webhook/secret");
    data.insert("address", "YOUR_ADDRESS");
    data.insert("amount", "0.133");
    data.insert("metadata", "[object Object]");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def checkout(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = {
  action: 'checkout',
  title: 'Nano Bird Feeder',
  notify: '[email protected]',
  webhook: 'https://example/webhook/secret',
  address: 'YOUR_ADDRESS',
  amount: '0.133',
  metadata: {
    secret: 'joe-doe'
  }
}

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function checkout($title) {
  $url = 'https://rpc.nano.to';
  $data = array({
  action: 'checkout',
  title: 'Nano Bird Feeder',
  notify: '[email protected]',
  webhook: 'https://example/webhook/secret',
  address: 'YOUR_ADDRESS',
  amount: '0.133',
  metadata: {
    secret: 'joe-doe'
  }
});
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> checkout(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{
  "action": "checkout",
  "title": "Nano Bird Feeder",
  "notify": "[email protected]",
  "webhook": "https://example/webhook/secret",
  "address": "YOUR_ADDRESS",
  "amount": "0.133",
  "metadata": {
    "secret": "joe-doe"
  }
}),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func checkout(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{
  action  "checkout",
  title  "Nano Bird Feeder",
  notify  "[email protected]",
  webhook  "https //example/webhook/secret",
  address  "YOUR_ADDRESS",
  amount  "0.133",
  metadata  {
    secret  "joe-doe"
  }
}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> checkout(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  {
  action = "checkout",
  title = "Nano Bird Feeder",
  notify = "[email protected]",
  webhook = "https //example/webhook/secret",
  address = "YOUR_ADDRESS",
  amount = "0.133",
  metadata = {
    secret = "joe-doe"
  }
}
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db '{
  action: checkout,
  title: Nano Bird Feeder,
  notify: [email protected],
  webhook: https://example/webhook/secret,
  address: YOUR_ADDRESS,
  amount: 0.133,
  metadata: {
    secret: joe-doe
  }
}', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{ "action": "market_data" }' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
action: "market_data"
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = { action: "market_data" }

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn market_data(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "market_data");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def market_data(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = { action: 'market_data' }

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function market_data($title) {
  $url = 'https://rpc.nano.to';
  $data = array({ action: 'market_data' });
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> market_data(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{ action: "market_data" }),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func market_data(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{"action": "market_data"}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> market_data(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  action = "market_data"
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db 'action: market_data', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{
  "action": "nano_email",
  "refund_address": "@bank",
  "amount": "5",
  "from": "",
  "message": "",
  "email_receipt": "",
  "expiration": "7 Days",
  "emails": [
    "[email protected]"
  ]
}' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
  "action": "nano_email",
  "refund_address": "@bank",
  "amount": "5",
  "from": "",
  "message": "",
  "email_receipt": "",
  "expiration": "7 Days",
  "emails": [
    "[email protected]"
  ]
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = {
  "action": "nano_email",
  "refund_address": "@bank",
  "amount": "5",
  "from": "",
  "message": "",
  "email_receipt": "",
  "expiration": "7 Days",
  "emails": [
    "[email protected]"
  ]
}

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn nano_email(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "nano_email");
    data.insert("refund_address", "@bank");
    data.insert("amount", "5");
    data.insert("from", "");
    data.insert("message", "");
    data.insert("email_receipt", "");
    data.insert("expiration", "7 Days");
    data.insert("emails", "[email protected]");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def nano_email(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = {
  action: 'nano_email',
  refund_address: '@bank',
  amount: '5',
  from: '',
  message: '',
  email_receipt: '',
  expiration: '7 Days',
  emails: [
    '[email protected]'
  ]
}

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function nano_email($title) {
  $url = 'https://rpc.nano.to';
  $data = array({
  action: 'nano_email',
  refund_address: '@bank',
  amount: '5',
  from: '',
  message: '',
  email_receipt: '',
  expiration: '7 Days',
  emails: [
    '[email protected]'
  ]
});
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> nano_email(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{
  "action": "nano_email",
  "refund_address": "@bank",
  "amount": "5",
  "from": "",
  "message": "",
  "email_receipt": "",
  "expiration": "7 Days",
  "emails": [
    "[email protected]"
  ]
}),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func nano_email(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{
  action  "nano_email",
  refund_address  "@bank",
  amount  "5",
  from  "",
  message  "",
  email_receipt  "",
  expiration  "7 Days",
  emails  [
    "[email protected]"
  ]
}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> nano_email(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  {
  action = "nano_email",
  refund_address = "@bank",
  amount = "5",
  from = "",
  message = "",
  email_receipt = "",
  expiration = "7 Days",
  emails = [
    "[email protected]"
  ]
}
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db '{
  action: nano_email,
  refund_address: @bank,
  amount: 5,
  from: ,
  message: ,
  email_receipt: ,
  expiration: 7 Days,
  emails: [
    [email protected]
  ]
}', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{
  "action": "buy_rpc",
  "email": "your_account_email",
  "key": "RPC-API-KEY"
}' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
  "action": "buy_rpc",
  "email": "your_account_email",
  "key": "RPC-API-KEY"
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = {
  "action": "buy_rpc",
  "email": "your_account_email",
  "key": "RPC-API-KEY"
}

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn buy_rpc(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "buy_rpc");
    data.insert("email", "your_account_email");
    data.insert("key", "RPC-API-KEY");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def buy_rpc(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = {
  action: 'buy_rpc',
  email: 'your_account_email',
  key: 'RPC-API-KEY'
}

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function buy_rpc($title) {
  $url = 'https://rpc.nano.to';
  $data = array({
  action: 'buy_rpc',
  email: 'your_account_email',
  key: 'RPC-API-KEY'
});
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> buy_rpc(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{
  "action": "buy_rpc",
  "email": "your_account_email",
  "key": "RPC-API-KEY"
}),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func buy_rpc(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{
  action  "buy_rpc",
  email  "your_account_email",
  key  "RPC-API-KEY"
}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> buy_rpc(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  {
  action = "buy_rpc",
  email = "your_account_email",
  key = "RPC-API-KEY"
}
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db '{
  action: buy_rpc,
  email: your_account_email,
  key: RPC-API-KEY
}', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$

curl -d '{
  "action": "rpc_credits",
  "key": "RPC-API-KEY"
}' \
-H "Content-Type: application/json" \
"https://rpc.nano.to"

const axios = require('axios');

axios.post('https://rpc.nano.to', {
  "action": "rpc_credits",
  "key": "RPC-API-KEY"
}).then((res) => {
  console.log(res.data);
});

import requests

url = 'https://rpc.nano.to'

myobj = {
  "action": "rpc_credits",
  "key": "RPC-API-KEY"
}

x = requests.post(url, json = myobj)

print(x.text)

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

async fn rpc_credits(title: &str) -> Result<reqwest::Response, reqwest::Error> {
    let client = Client::new();
    let url = "https://rpc.nano.to"

    let mut data = HashMap::new();
    data.insert("action", "rpc_credits");
    data.insert("key", "RPC-API-KEY");
    

  let res = client
    .post(url)
    .json(&data)
    .send()
    .await?;

  Ok(res)
}

require 'net/http'
require 'uri'
require 'json'

def rpc_credits(title)
  uri = URI.parse('https://rpc.nano.to')
  header = {'Content-Type': 'application/json'}
  data = {
  action: 'rpc_credits',
  key: 'RPC-API-KEY'
}

  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = data.to_json

  response = http.request(request)
  response.body
end

<?php
function rpc_credits($title) {
  $url = 'https://rpc.nano.to';
  $data = array({
  action: 'rpc_credits',
  key: 'RPC-API-KEY'
});
  $options = array(
    'http' => array(
      'header'  => "Content-Type: application/json\r\n",
      'method'  => 'POST',
      'content' => json_encode($data),
    ),
  );
  $context  = stream_context_create($options);
  $result = file_get_contents($url, false, $context);
  if ($result === FALSE) { /* Handle error */ }

  return $result;
}

// import 'dart:convert';
Future<http.Response> rpc_credits(String title) {
  return http.post(
  Uri.parse('https://rpc.nano.to'),
  headers: <String, String>{
    'Content-Type': 'application/json',
  },
  body: jsonEncode(<String, String>{
  "action": "rpc_credits",
  "key": "RPC-API-KEY"
}),
)}

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
)

func rpc_credits(title string) (*http.Response, error) {
  url := "https://rpc.nano.to"
  data := map[string]interface{}{
  action  "rpc_credits",
  key  "RPC-API-KEY"
}

  jsonData, err := json.Marshal(data)
  if err != nil {
      return nil, err
  }

  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  if err != nil {
      return nil, err
  }
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
      return nil, err
  }

  return resp, nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ApiClient {
    private static readonly HttpClient client = new HttpClient();

    public static async Task<HttpResponseMessage> rpc_credits(string title) {
        var uri = new Uri("https://rpc.nano.to");
        var data = new {
  {
  action = "rpc_credits",
  key = "RPC-API-KEY"
}
        };

        var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

        return await client.PostAsync(uri, content);
    }
}

section .data
  url db 'https://rpc.nano.to', 0
  header db 'Content-Type: application/json', 0
	    data db '{
  action: rpc_credits,
  key: RPC-API-KEY
}', 0

section .bss
  response resb 256

section .text
  global _start

_start:
  ; Normally here you would set up a socket and perform the HTTP request
  ; For simplicity, print the URL, headers, and data

  ; Print URL
  mov edx, len url
  mov ecx, url
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Header
  mov edx, len header
  mov ecx, header
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Print Data
  mov edx, len data
  mov ecx, data
  mov ebx, 1
  mov eax, 4
  int 0x80

  ; Exit
  mov eax, 1
  xor ebx, ebx
  int 0x80

len equ $ - $$