Nano.to PoW API

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 $ - $$