Nodex Pay

https://nodex-pay.gitbook.io/docs
Admin
Nodex Pay is a decentralized cryptocurrency payment gateway that enables businesses to accept...
Tokens:28,342
Snippets:206
Trust Score:9.8
Update:1 month ago
Show doc for...
Tokens:
Raw
### Go Payment Request with Settlement Amount

Source: https://nodex-pay.gitbook.io/docs/integration-guide/apis/payment-request-api.md

Go example for creating a payment request when the business client sets the settlement amount. Generates a verify token using SHA-256, sends a POST request to the payment endpoint, and prints the payment flow starting URL or errors.

```go
package main

import (
  "crypto/sha256"
  "encoding/hex"
  "encoding/json"
  "fmt"
  "io/ioutil"
  "net/http"
  "net/url"
)

func main() {
  // api-endpoint
  API_ENDPOINT := "https://testnet.app.nodexpay.com/api/v1/payment/receive"

  // Authentication Token
  AUTH_TOKEN := "YOUR AUTHENTICATION TOKEN"

  // Hash Token
  HASH_TOKEN := "YOUR HASH TOKEN"

  // Code set by the business client (Integrator) to uniquely identify the payment
  ORDER_CODE := "GENERATE UNIQUE CODE AND STORE IT ON YOUR DATABASE"

  // Set amount and Generate verify token
  amount_to_be_charged := 10.00 // this number must be Zero or more
  raw := fmt.Sprintf("%s::%f::%s", ORDER_CODE, amount_to_be_charged, HASH_TOKEN)
  verify_token := sha256.Sum256([]byte(raw))

  // data to be sent to api
  data := url.Values{}
  data.Add("identification_token", AUTH_TOKEN)
  data.Add("order_code", ORDER_CODE)
  data.Add("verify_token", hex.EncodeToString(verify_token[:]))
  data.Add("amount", fmt.Sprintf("%f", amount_to_be_charged))

  // sending post request and saving response as response object
  res, _ := http.PostForm(API_ENDPOINT, data)
  defer res.Body.Close()

  body, _ := ioutil.ReadAll(res.Body)

  var responseObj interface{}
  _ = json.Unmarshal(body, &responseObj)

  url := responseObj.(map[string]interface{})["url"]
  if url != nil {
    fmt.Printf("url: %s\n", url)
  } else {
    err := responseObj.(map[string]interface{})["errors"]
    fmt.Println(err)
  }
}
```

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

### Query Documentation via HTTP GET

Source: https://nodex-pay.gitbook.io/docs/integration-guide/advanced-features.md

Perform an HTTP GET request on the current page URL with the ask query parameter and an optional goal parameter to retrieve information dynamically.

```http
GET https://nodex-pay.gitbook.io/docs/integration-guide/advanced-features.md?ask=<question>&goal=<endgoal>
```

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

### 200 Nodex Pay invoice successfully created

Source: https://nodex-pay.gitbook.io/docs/integration-guide/apis/payment-request-api.md

Successful response from the payment creation request. The first example shows the default response when ext_reserved and ext_description are not provided. The second example shows the response when those fields are included.

```javascript
{
    "url": "https://app.nodexpay.com/payment/PAYMENT_TOKEN_ISSUED_BY_NODEX",
    "token": "PAYMENT_TOKEN_ISSUED_BY_NODEX",
    "ext_reserved": "",
    "ext_description": ""
}
```

```javascript
{
    "url": "https://app.nodexpay.com/payment/PAYMENT_TOKEN_ISSUED_BY_NODEX",
    "token": "PAYMENT_TOKEN_ISSUED_BY_NODEX",
    "ext_reserved": "0x00000000000000000............",
    "ext_description": "This value you input as ext_description"
}
```

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

### Generate payment URL with fixed amount (Java)

Source: https://nodex-pay.gitbook.io/docs/integration-guide/apis/payment-request-api.md

Java example for generating a payment URL when the integrator sets the amount. It computes a SHA-256 verify token from order_code, amount, and HASH_TOKEN, then POSTs to the API endpoint with identification_token, order_code, verify_token, and amount. Requires the org.json library; otherwise a compile error occurs.

```java
import java.net.URL;
import java.net.HttpURLConnection;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.io.BufferedReader;
import java.io.InputStreamReader;

import java.security.MessageDigest;
import org.json.JSONObject; // Note: that if "org.json" library is not present, a compile error will occur

public class GeneratePaymentURL {
    public static void main(String[] args) {
        // api-endpoint
        final String API_ENDPOINT = "https://testnet.nodexpay.app.com/api/v1/payment/receive";

        // Authentication Token
        final String AUTH_TOKEN = "YOUR AUTHENTICATION TOKEN";

        // Hash Token
        final String HASH_TOKEN = "YOUR HASH TOKEN";

        // Code set by the business client (Integrator) to uniquely identify the payment
        String order_code = "GENERATE UNIQUE CODE AND STORE IT ON YOUR DATABASE";

        // Set amount and Generate verify token
        Float amount_to_be_charged = 10.0f;

        try{
            // generate verify token
            String raw = String.format("%s::%.2f::%s", 
                                    order_code, amount_to_be_charged, HASH_TOKEN);
            MessageDigest md = MessageDigest.getInstance("SHA-256");
            md.update(raw.getBytes());
            byte[] verify_byte = md.digest();

            StringBuilder verify_token = new StringBuilder(2 * verify_byte.length);
            for (byte b: verify_byte) {
                verify_token.append(String.format("%02x", b&0xff));
            }

            // POST
            URL url = new URL(API_ENDPOINT);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setDoOutput(true); // allow POST
            conn.setRequestMethod("POST");
            conn.connect();

            // POST params
            String params = String.format("identification_token=%s&order_code=%s&verify_token=%s&amount=%.2f", 
                                        AUTH_TOKEN, order_code, verify_token, amount_to_be_charged);

            OutputStream os = conn.getOutputStream();
            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(os));
            writer.write(params);
            writer.flush();
            writer.close();
            os.close();

            BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
            StringBuilder sb = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
            String result = sb.toString();

            JSONObject obj = new JSONObject(result);
            String payment_url = obj.getString("url");

            System.out.println("The URL is: " + payment_url);

        } catch (Exception e) {
            System.out.println(e);
        }
    }
}
```

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

### Create Payment Request with PHP and Ruby

Source: https://nodex-pay.gitbook.io/docs/integration-guide/apis/payment-request-api.md

Sample code for creating a payment request using the NodeX Pay API. It sets up the API endpoint, authentication token, and hash token, generates a verify token by hashing the order code, amount, and hash token, then sends a POST request to receive a payment URL. The response contains the URL to start the payment flow.

```php
<?php

// api-endpoint
define("API_ENDPOINT", "https://testnet.app.nodexpay.com/api/v1/payment/receive");
// Authentication Token
define("AUTH_TOKEN", "YOUR AUTHENTICATION TOKEN");
// Hash Token
define("HASH_TOKEN", "YOUR HASH TOKEN");

// Code set by the business client (Integrator) to uniquely identify the payment
$order_code = "GENERATE UNIQUE CODE AND STORE IT ON YOUR DATABASE";

// Set amount
$amount_to_be_charged = 10; // this number must be Zero or more

// Generate verify token
$generate_params = [
  "order_code" => $order_code,
  "amount" => $amount_to_be_charged,
  "hash_token" => HASH_TOKEN
];
$raw = implode("::", $generate_params);
$verify_token = hash("sha256", $raw);

// Data to be sent to api
$request_params = [
  "identification_token" => AUTH_TOKEN,
  "order_code" => $order_code,
  "amount" => $amount_to_be_charged,
  "verify_token" => $verify_token
];

// Sending post request and saving response as response object
$curl_handler = curl_init(API_ENDPOINT);
curl_setopt($curl_handler, CURLOPT_POST, true);
curl_setopt($curl_handler, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($curl_handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl_handler, CURLOPT_POSTFIELDS, $request_params);
$response = curl_exec($curl_handler);
curl_close($curl_handler);

// Extracting response text
$data = json_decode($response);
echo "The URL is:{$data->url}";
```

```ruby
require 'net/http'
require 'digest'
require 'json'

# api-endpoint
API_ENDPOINT  = URI.parse('https://testnet.app.nodexpay.com/api/v1/payment/receive')

# Authentication Token
AUTH_TOKEN = "YOUR AUTHENTICATION TOKEN"

# Hash Token
HASH_TOKEN = "YOUR HASH TOKEN"

# Code set by the business client (Integrator) to uniquely identify the payment
order_code = "GENERATE UNIQUE CODE AND STORE IT ON YOUR DATABASE"

# Set amount and Generate verify token
amount_to_be_charged = 10 # this number must be Zero or more
raw = "#{order_code}::#{amount_to_be_charged}::#{HASH_TOKEN}"
verify_token = Digest::SHA256.hexdigest(raw)

# data to be sent to api
data = {
  'identification_token': AUTH_TOKEN,
  'order_code': order_code,
  'verify_token': verify_token,
  'amount': amount_to_be_charged
}

# sending post request and saving response as response object
r = Net::HTTP.post_form(API_ENDPOINT, data)

# extracting response text
payment_flow_starting_url = JSON.parse(r.body)['url']
p "The URL is: #{payment_flow_starting_url}"
```

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

### Implement Payment Status API in Python

Source: https://nodex-pay.gitbook.io/docs/integration-guide/integration-guide/implement-apis.md

Provides a GET endpoint to retrieve order information based on a payment token.

```python
def get_order():
    query = NodexOrder.select()
    return json.loads(json.dumps(list(query.dicts()), default=str))
 
@app.route('/order', methods=['GET'])
def get_order_route():
    payment_token = request.args.get('payment_token')
    print(payment_token)
    orders = get_order()
    print(orders)
    return jsonify(orders)
```

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

### Next.js: Create order and redirect to payment URL

Source: https://nodex-pay.gitbook.io/docs/integration-guide/integration-guide/implement-frontend-and-integrate-apis.md

Use this Next.js function to call the API created in the previous section. It posts to `process.env.API_URL_CREATE_ORDER_NORMAL` and redirects to `result.data.paymentUrl` on success. On failure, it alerts the user to continue or restart the payment.

```javascript
const callCheckout = async (data) => {
  // call the API that you created previous section
  const apiUrl = process.env.API_URL_CREATE_ORDER_NORMAL
  const result = await axios.post(apiUrl).catch(error => {
    console.log(error.response)
  });
  if (result.status === 200) {
    window.location = result.data.paymentUrl
  } else {
    alert('You have already started this payment. Please continue the payment or start from order again.')
  }
}

return (
//...

  <form onSubmit={handleSubmit(callCheckout)}>
    <div className='...'>
      <button type='submit'>
        <Image src='/nodex_pay.png' width='xxx' height='xx' alt='crypto pay' />
      </button>
    </div>
  </form>

//...
)
```

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

### Store purchasing data in Python

Source: https://nodex-pay.gitbook.io/docs/integration-guide/integration-guide/implement-apis.md

Registers the order details in the database using the NodexOrder model.

```python
NodexOrder.create(
    order_code = data['order_code'],
    amount = data['amount'],
    fiat_symbol = data['amount_type'],
    payment_token = data['token'],
    order_status = 'initiated',
)
```

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

### Implement Payment Result API in Python

Source: https://nodex-pay.gitbook.io/docs/integration-guide/integration-guide/implement-apis.md

Minimal implementation of a POST route to handle payment result kickbacks and update the order status in the database.

```python
def update_payment_status(order_code, result):
    order = NodexOrder.select().where(NodexOrder.order_code == order_code).get() # find order by order_code
    order.order_status = 'settled' if result else 'failed' # update order status
    order.save() # save order
 
@app.route('/nodex-kickback/payment', methods=['POST'])
def nodex_payment_kickback_route():
    body = request.json
    update_payment_status(order_code=body['order_code'], result=body['result']) # save result to database
    return 'ok'
```

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

### Call Payment Request API in Python

Source: https://nodex-pay.gitbook.io/docs/integration-guide/integration-guide/implement-apis.md

Generates payment data, creates a SHA-256 verification token, and sends a POST request to the Nodex Pay system.

```python
# business clients has to implement new
amount = 1 # Price
amount_type = 'USD' # Currency of the Price
order_code = generateOrderCode() # Unique per api call
 
# automatically generated on the business client management screen
authentication_token = os.getenv('NODEX_AUTH_TOKEN')
hash_token = os.getenv('NODEX_HASH_TOKEN')
 
# encrypto followin Nodex's manners
raw = '{}::{}::{}'.format(order_code, amount, hash_token)
verify_token = hashlib.sha256(raw.encode('utf-8')).hexdigest()
 
# call Payment Request API
request_obj = {
    'identification_token': authentication_token,
    'order_code': order_code,
    'verify_token': verify_token,
    'amount': amount,
    'amount_type': amount_type
}
payment_request_url = os.getenv('NODEX_PAYMENT_REQUEST_URL')
r = requests.post(url = payment_request_url, data = request_obj)

result = r.json()
 
# returned values
payment_url = result['url']
payment_token = result['token']
```

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

### HTML + JavaScript: Create order and open payment URL

Source: https://nodex-pay.gitbook.io/docs/integration-guide/integration-guide/implement-frontend-and-integrate-apis.md

Use this HTML page with embedded JavaScript to create a payment order via axios POST to `${API_URL}/create-order`. On success, it opens the returned `payment_url` in a new tab. Replace `YOUR_API_URL` with your actual API endpoint.

```html
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Store</title>
 
  <link rel="stylesheet" href="styles.css">
</head>
<body>
  <div class="card">
    <img src="tshirt.jpg" alt="Tshirt" style="width:100%">
    <h1>Cotton T-shirt</h1>
    <p class="price">$0.001</p>
    <p>ATC 5050 Everyday Cotton Blend Tee</p>
    <p><button onclick="handleOrder()">Buy</button></p>
  </div>
</body>
 
<script src="https://unpkg.com/axios/dist/axios.min.js"></script>
<script>
  const API_URL = 'YOUR_API_URL'
 
  function handleOrder() {
    axios.post(`${API_URL}/create-order`, {amount: '0.001'})
      .then((res) => {
        console.log('res', res.data)
        const {data} = res
        if(data.payment_url) {
          console.log('vao day')
          window.open(data.payment_url, '_blank').focus();
        }
      })
      .catch(err => {
        alert('error')
        console.error(err)
      })
  }
</script>
</html>
```

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

### Return Nodex Pay URL in Python

Source: https://nodex-pay.gitbook.io/docs/integration-guide/integration-guide/implement-apis.md

Returns the payment URL to the client.

```python
return {
    'payment_url': payment_url
}
```

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

### Next.js: Fetch and display order after payment

Source: https://nodex-pay.gitbook.io/docs/integration-guide/integration-guide/implement-frontend-and-integrate-apis.md

Use this Next.js component to fetch order details using the payment_token from the router query and display them. It uses useEffect to call an async function once the router is ready, and shows an alert on error.

```javascript
const [order, setOrder] = useState({})
const router = useRouter()

const asyncInit = async () => {
  const order = await callGetOrderByPaymentToken()
  setOrder(order)
}

useEffect(() => {
  if (!router.isReady) return;
  asyncInit()
}, [router.isReady])

const callGetOrderByPaymentToken = async () => {
  const apiUrl = `${process.env.API_URL_GET_ORDER_BY_PAYMENT_TOKEN}?payment_token=${router.query.payment_token}`
  const result = await axios.get(apiUrl)
  if (result.status === 200) {
    return result.data.order
  } else {
    alert('error!')
  }
}

//...

return (
//...

// render "order" state with purchase completed message

//...
)
```

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

### Generate Payment URL with Fixed Settlement Amount

Source: https://nodex-pay.gitbook.io/docs

Use this Python snippet when the business client (integrator) defines the specific payment amount. It requires an authentication token, hash token, and a unique order code to generate a verify token via SHA-256.

```python
import requests
import hashlib
  
# api-endpoint
API_ENDPOINT = "https://testnet.app.nodexpay.com/api/v1/payment/receive"

# Authentication Token
AUTH_TOKEN = "YOUR AUTHENTICATION TOKEN";

# Hash Token
HASH_TOKEN = "YOUR HASH TOKEN";
  
# Code set by the business client (Integrator) to uniquely identify the payment
order_code = "GENERATE UNIQUE CODE AND STORE IT ON YOUR DATABASE"

# Set amount and Generate verify token
amount_to_be_charged = 10 # this number must be Zero or more
raw = '{}::{}::{}'.format(order_code, amount_to_be_charged, HASH_TOKEN)
verify_token = hashlib.sha256(raw).hexdigest()

# data to be sent to api
data = {'identification_token':AUTH_TOKEN,
        'order_code':order_code,
        'verify_token':verify_token,
        'amount':amount_to_be_charged}
  
# sending post request and saving response as response object
r = requests.post(url = API_ENDPOINT, data = data)
  
# extracting response text 
payment_flow_starting_url = r.url
print("The URL is:%s"%payment_flow_starting_url)
```

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

### HTML + JavaScript: Fetch and display order after payment

Source: https://nodex-pay.gitbook.io/docs/integration-guide/integration-guide/implement-frontend-and-integrate-apis.md

Use this HTML page with embedded JavaScript to fetch order details using the payment_token from the URL query string and render them in a table. It uses Axios to call the API endpoint and displays product name, order date/time, order code, and status.

```html
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Store</title>
 
    <link rel="stylesheet" href="styles.css" />
  </head>
  <body>
    <div class="content">
      <h3>Your order</h3>
      <table id="order-table">
        <tr>
          <th>PRODUCT NAME</th>
          <th>DATE TIME ORDERED</th>
          <th>YOUR ORDER CODE</th>
          <th>STATUS</th>
        </tr>
      </table>
    </div>
  </body>
 
  <script src="https://unpkg.com/axios/dist/axios.min.js"></script>
  <script>
    const url = new URL(window.location);
    const paymentToken = url.searchParams.get("payment_token");
    const API_URL = 'YOUR_API_URL';
 
    const table = document.getElementById("order-table");
 
    axios
      .get(`${API_URL}/order`, { params: { payment_token: paymentToken } }) // get order
      .then((res) => {
        const orders = res.data;
        orders.forEach((order, i) => {
          // render order
          const row = table.insertRow(i + 1);
 
          const productName = row.insertCell(0);
          productName.innerHTML = order.product_id;
 
          const dateTimeOrder = row.insertCell(1);
          dateTimeOrder.innerHTML = order.order_date_time;
 
          const orderCode = row.insertCell(2);
          orderCode.innerHTML = order.order_code;
 
          const status = row.insertCell(3);
          status.innerHTML = order.order_status;
        });
      });
  </script>
</html>
```

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

### Store purchasing data in Node.js + DynamoDB

Source: https://nodex-pay.gitbook.io/docs/integration-guide/integration-guide/implement-apis.md

Saves the order information to a DynamoDB table using the AWS SDK.

```javascript
const puttingItem = {
  order_code: orderCode, /* a value generated at previous section */
  amount: amount,
  amount_type: amountType,
  payment_token: paymentToken, /* a value returned at previous section */
  status: 'initiated', /* anything you want */
}

const putParams = {
  TableName: process.env.DYNAMODB_CUSTOMER_TABLE,
  Item: puttingItem,
}

await dynamoDb.put(putParams)
```

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

### Call Payment Request API in Node.js

Source: https://nodex-pay.gitbook.io/docs/integration-guide/integration-guide/implement-apis.md

Generates payment data, creates a SHA-256 hash, and uses axios to post the request to the Nodex Pay system.

```javascript
// business clients has to implement new
const amount = 1 /* Price */
const amountType = 'USD' /* Currency of the Price  */  
const orderCode = generateOrderCode() /* Unique per api call  */  

// automatically generated on the business client management screen
const authenticationToken = process.env.NODEX_AUTH_TOKEN
const hashToken = process.env.NODEX_HASH_TOKEN

// encrypto followin Nodex's manners
const raw = orderCode + '::' + amount + '::' + hashToken
const hashHex = crypto.createHash('sha256').update(raw, 'utf8').digest('hex')

// call Paument Request API
const requestObj = {
  identification_token: authenticationToken,
  order_code: orderCode,
  verify_token: hashHex,
  amount: amount,
  amount_type: amountType,
}
const paymentRequestUrl = process.env.PAYMENT_REQUEST_URL
const result = await axios.post(paymentRequestUrl, requestObj).catch((error) => {
  return error.response
})

if (result.status !== 200) {
  return {
    statusCode: result.status,
    body: JSON.stringify(result.data),
    headers: {
      'Content-Type': 'application/json',
    }
  }
}

// returned values
const paymentUrl = result.data.url
const paymentToken = result.data.tokens
```
Tokens:
Raw