API aracılığıyla kripto ödemelerini bağlama

let createPaymentObj =
    {
        userSecret: 'your_API_key', // required
        userPaymentId: 'your_payment_id_usually_order_id', // required
        blockchain: 'tether-trc20', // required 
        fiatCode: '3x_ISO_code_of_your_fiat_currency_for example_EUR', // required
        customerEmail: 'customer_mail', // required

        fiatAmount: 'digit_amount_in_fiat_currency_for_example_100', // number, required
        userProductId: 'your_product_id_if_any', // not required
        language: 'two_digit_ISO_language_code', // default en, not required [available: en, cz, ru, tr, my, hr, si, ar, swa] - the rest will be an error
        // redirectUrl_yours: 'thank_you_page or success_page',
        redirectUrl_yours: 'url_on_your_site_where_to_send_user_after_successful_payment', // not required, but very desirable
        webHookPostUrl_yours: 'url_on_your_site_where_the_hidden_POST_request_will_go_on_successful_payment,' // required
    }

headers: {
     'Content-Type': 'application/json',
     accept: 'application/json',
     'mitilena-signature': 'your_key',
}

{
  usdtOverAmount: '1.580437',
  invoiceId: 'auto-e80099-ef456c-e0de42',
  invoiceVs: '0437',
  fiatAmount: '1.450',
  fiatCurrency: 'EUR',
  rateLocalCurrencyToNeededCrypto: '0.917',
  rateNeededCryptoToUSD: '0.99959700',
  isTrc20: 1,
  isErc20: 0,
  isBep20: 0,
  whenInit: '2023-08-22T11:30:05.000Z',
  contractAddress: 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t',
  customerEmail: 'email_customer@email.com',
  productId: 85,
  expiresAt: '2023-09-05T11:30:05.000Z',
  blockchainHash: null,
  cryptoShortCode: 'USDT',
  cryptoValue: '1.580437',
  fiatValue: '1.450',
  receivedOnAddress: 'TRHpcBugcdEdD6BdW6k1Grtof6LBvRGWWJ',
  txId: 'auto-e80099-ef456c-e0de42',
  fiatShortCode: 'EUR',
  wasPaid: null,
  redirectUrl: 'https://google.com',
  paymentPage: 'https://mitilena.com/pay/auto-e80099-ef456c-e0de42/fast/'
}

const https = require('https');
const url = require('url');

const data = JSON.stringify({
    userSecret: '',
    userPaymentId: 'userPaymentdId111',
    blockchain: 'tether-trc20',
    fiatCode: 'EUR',
    customerEmail: 'email_customer@email.com',

    fiatAmount: 1.45,
    userProductId: 'new_someGoodsOk',
    language: 'en', // default en, not neccessary
    // redirectUrl_yours: 'https://google.com',
    redirectUrl_yours: 'https://google.com',
    webHookPostUrl_yours: 'https://mitilena.com/mi_webhook/'
});

const myURL = url.parse('https://mitilena.com/api/generatePayment');

const options = {
    hostname: myURL.hostname,
    port: myURL.port,
    path: myURL.pathname,
    method: 'POST',
    headers: {
        'Content-Type': 'application/json',
        accept: 'application/json',
        'mitilena-signature': '',
    },
};

requestAsync(options, data)
    .then(dataFObj => {
        if (dataFObj.statusCode === 200) {
            let tokensObj = JSON.parse(dataFObj.dataRaw);
            console.log('success:', tokensObj)
        } else {
            console.log('error dataFObj', dataFObj);
            throw new Error('some errror in postToWebHook ' + dataFObj.dataRaw);
        }
    })
    .catch(e => {
        console.log('error request:', e)
    })


function requestAsync(optionsArr, dataToPost = false) {
    return new Promise((resolve, reject) => {
        const req = https.request(optionsArr, (resp) => {
            // console.log(`statusCode: ${resp.statusCode}`);
            let dataF = '';
            // A chunk of data has been received.
            resp.on('data', (chunk) => {
                dataF += chunk;
            });

            resp.on('end', () => {
                resolve({statusCode: resp.statusCode, dataRaw: dataF});
            }).on('error', (err) => {
                console.log('Error: ' + err);
                reject(err);
            });
        });

        if (dataToPost) {
            req.write(dataToPost);
        }

        req.end();
    });
}

<?php
$request_body = [
    'userSecret' => $this->mitilenaToken,
    'userPaymentId' => $order->id,    
    'blockchain' => 'tether-trc20',
    'fiatCode' => $order->currency,    
    'customerEmail' => $order->get_billing_email(),

    'fiatAmount' => $order->get_total(),
    'userProductId' => $orderids,
    'language' => 'en', // default en, not neccessary
    'redirectUrl_yours' => $order->get_checkout_order_received_url(),
    'webHookPostUrl_yours' => 'https://mywebsite.com/post-handler.php'

];

$request_headers = [
    'content-type' => 'application/json',
    'mitilena-signature' => $this->mitilenaToken,
];

$args = [
    'method' => 'POST',
    'httpversion' => '1.0',
    'timeout' => 90,
    'headers' => $request_headers,
    'body' => ''
];

$environment_url = 'https://mitilena.com/api/generatePayment/';

$result = wp_remote_post($environment_url, array(
        'method' => 'POST',
        'headers' => $request_headers,
        'timeout' => 60, // added
        'redirection' => 5,  // added
        'blocking' => true, // added
        'httpversion' => '1.0',
        'sslverify' => false,
        'body' => json_encode($request_body))
);

$fullObj = json_decode($result['body']);

if (isset($result['response']) && isset($result['response']['code']) && $result['response']['code'] != 200) {
    $mi__err_message = 'Unknown error';
    if (isset($result['body'])) {
        $mi__err_message = 'Error: ' . $result['body'];
    }
    // error handling + exit
    exit;
}

if (!isset($fullObj->paymentPage)) {
    http_response_code(400); // Bad Request
    echo "Error: No payment page specified";
    exit;
}
$paymentPage = $fullObj->paymentPage;

if (strlen($paymentPage) < 5) {
    http_response_code(400); // Bad Request
    echo "Error: payment page is too short.";
    exit;
}
?>

const bodyParser = require('body-parser');
const Big = require('big.js')
let endpointSecret = 'copy of the api key value'

// an object called statusObj arrives
app.post('/mi_webhook/', bodyParser.json(), (request, response) => {

    try {
        let eventObj = request.body;
        const signature = request.headers['mitilena-signature'];

        console.log({eventObj});
// compare the incoming secret key with your real one
        if (signature === endpointSecret) {
            if (!eventObj.statusObj) {
                return response.status(400).send('Error, no object.');
            }

            let hookObj = eventObj.statusObj;

            if (
                typeof hookObj.mitilenaInvoiceId === 'undefined' ||
                typeof hookObj.yourPaymentId === 'undefined' ||
                typeof hookObj.yourProductName === 'undefined' ||
                typeof hookObj.yourProductId === 'undefined' ||
                typeof hookObj.secretKey === 'undefined' ||
                typeof hookObj.stableCoinAmount === 'undefined' ||
                typeof hookObj.stableCoinSymbol === 'undefined' ||
                typeof hookObj.stableCoinBlockchain === 'undefined' ||
                typeof hookObj.localCurrencyAmount === 'undefined' ||
                typeof hookObj.localCurrencyCode === 'undefined' ||
                typeof hookObj.wasPaid === 'undefined' ||
                typeof hookObj.blockchainHash === 'undefined'
            ) {
                return response.status(400).send('Error, incomplete object.');
            }

            if (hookObj.wasPaid === true) {
                let centsAmount = Big(hookObj.localCurrencyAmount).times(Big(100)).round(0).toNumber();

// put the order in your database as paid and return the status code 200
// this is an example of our code, yours may look different
                paymentsModel
                    .completeUserPayment(hookObj.mitilenaInvoiceId, centsAmount)
                    .then((okString) => {
                        return response.status(200).send('all good Mitilena token');
                    })
                    .catch((e) => {
                        console.log('err in completeUserCardPayment', e.message);
                        return response.status(400).send('error, contact support');
                    });
            } else {
                return response.status(400).send('invoice was not paid');
            }
        } else {
            return response.status(400).send('bad Mitilena token');
        }
    } catch (e) {
        console.log('webhook err:', e.message);
        return response.status(400).send('bad request, error');
    }
});

<?php
$mi__jsonData = file_get_contents('php://input');
if (!$mi__jsonData) {
    http_response_code(400); // Bad Request
    echo 'bad input data';
    exit;
}
// Decode the JSON data into a PHP associative array
$mitilena_data = json_decode($mi__jsonData, true);


// Check if decoding was successful
if ($mitilena_data !== null && isset($mitilena_data['statusObj'])) {
    $mitilena_data = $mitilena_data['statusObj'];

    if (!isset($mitilena_data['secretKey'])) {
        http_response_code(400); // Bad Request
        echo "Error: Api key of Mitilena (Mitilena Token) is not specified. We can't verify if the request is genuine. Cancellation of a transaction.";
        exit;
    }
    $mitilenaToken = $mitilena_data['secretKey'];

    // compare your real API key with the one you received
    $realMitilenaToken = 'your_api_key'


    if ($mitilenaToken != $realMitilenaToken) {
        http_response_code(400); // Bad Request
        echo "Error: API token does not match. The website owner must specify the correct Api Mitilena token.";
        exit;
    }


    if (!isset($mitilena_data['yourPaymentId'])) {
        http_response_code(400); // Bad Request
        echo "Error: No payment id specified";
        exit;
    }
    $mi__paymentId = $mitilena_data['yourPaymentId'];

    if (strlen($mi__paymentId) < 1) {
        http_response_code(400); // Bad Request
        echo "Error: too short payment id.";
        exit;
    }
    
    function mi__pay_escapeString($var)
    {
        $var = stripslashes($var);
        $var = htmlentities($var);
        $var = strip_tags($var);
        return $var;
    }

    // yourPaymentId
    try {
        $mi__order = '';  // search your database for this order, mi__pay_escapeString($mi__paymentId)
    } catch (Throwable $e) {
        http_response_code(400); // Bad Request
        echo "Error: wrong payment id (order id). {yourPaymentId: \"\"}";
        exit;
    }

    if (!isset($mitilena_data['wasPaid'])) {
        http_response_code(400); // Bad Request
        echo "Error: No payment status specified";
        exit;
    }
    $mi__wasPaid = $mitilena_data['wasPaid'];


    if ($mi__wasPaid == true) {

        $blockchainHash = '';
        if (isset($mitilena_data['blockchainHash'])) {
            $blockchainHash = mi__pay_escapeString($mitilena_data['blockchainHash']);
        }

        // set the order as paid in your database
        // reduce inventory if required
        // send the user an email if required

        echo 'success';
    } else {
        echo 'unpaid status received';
    }
 } else {

    // JSON decoding failed
    http_response_code(400); // Bad Request
    echo "Invalid JSON data";
}

exit;
?>