# Generate a private key and save it to the `private.key.pem` file
openssl genpkey -algorithm ed25519 -out private_key.pem

# Extract the public key from the private key and save it to the `public.key.pem` file
openssl pkey -in private_key.pem -pubout -out public_key.pem

# Export the private key in hexadecimal format
openssl pkey -in private_key.pem -text | \
grep 'priv:' -A 3 | tail -n +2 | tr -d ':\n '

# Export the public key in hexadecimal format
openssl pkey -pubin -in public_key.pem -text | \
grep 'pub:' -A 3 | tail -n +2 | tr -d ':\n '

<dependency>
    <groupId>io.openweb3</groupId>
    <artifactId>walletpay</artifactId>
    <version>0.2.15</version>
</dependency>

implementation 'io.openweb3:walletpay:0.2.15'

import (
    "log"

    walletpay "github.com/openweb3-io/wallet-pay-openapi/go"
)

const ( 
    ApiKey = "YOUR_API_KEY"
    Secret = "YOUR_SECRET"
)

func main() {
    // Initialize ApiClient 
    client := walletpay.New(&walletpay.ApiClientOptions{
        ApiKey: ApiKey,
        Secret: Secret,
    })
}

import { ApiClient } from "@openweb3-io/wallet-pay";

const ApiKey = "YOUR_API_KEY";
const Secret = "YOUR_SECRET";

const client = new ApiClient(ApiKey, Secret, {});

import io.openweb3.walletpay.ApiClient;
import io.openweb3.walletpay.ApiClientOptions;

public class WalletPayExample {
    public static void main(String[] args) {
        String apiKey = "YOUR_API_KEY";
        String secret = "YOUR_SECRET";
        ApiClient apiClient = new ApiClient(
                new ApiClientOptions()
                        .apiKey(apiKey)
                        .privateKey(secret)
        );
    }
}

<?php

// The sodium extension is required (PHP >= 7.2.0)
if (!extension_loaded('sodium')) {
    die("Sodium extension required");
}

$body = 'post body data';
$uri = 'request uri';
$timestamp = 'current timestamp';

$content = $body . $uri . $timestamp;

// SHA-256 hash calculation
$hash = hash('sha256', $content, true);

// Decode API secret
$apiSecret = hex2bin('YOUR_API_SECRET');

// Generate key pair from seed
$keyPair = sodium_crypto_sign_seed_keypair($apiSecret);
$secretKey = sodium_crypto_sign_secretkey($keyPair);

// Ed25519 signature
$signature = sodium_crypto_sign_detached($hash, $secretKey);
echo "Signature: " . bin2hex($signature) . PHP_EOL;

import (
    "context"
    "encoding/json"
    "log"
    "math/big"

    walletpay "github.com/openweb3-io/wallet-pay-openapi/go"
)

const ( 
    ApiKey = "YOUR_API_KEY"
    Secret = "YOUR_SECRET"
)

func create() {
    // Initialize ApiClient 
    client := walletpay.New(&walletpay.ApiClientOptions{
        Debug:  true,
        ApiKey: ApiKey,
        Secret: Secret,
    })

    // 1 USDT
    currencyCode := "USDT"
    amount := "1"

    currency, err := client.Currencies.FindByCode(context.Background(), currencyCode)
    if err != nil {
        log.Fatal(err)
    }

    // amountInBaseUnit = amount * 10^decimals
    amountBig, ok := new(big.Int).SetString(amount, 10)
    if !ok {
        log.Fatal("invalid amount")
    }
    
    // 10^decimals
    exp := new(big.Int).Exp(big.NewInt(10), big.NewInt(int64(currency.Decimals)), nil)
    
    // amount * 10^decimals
    amountInBaseUnit := new(big.Int).Mul(amountBig, exp)

    order, err := client.Orders.Create(context.Background(), &walletpay.CreateOrderRequest{
        Currency:   currencyCode,
        Amount:     amountInBaseUnit.String(), 
        Expiration: walletpay.PtrInt32(10),
        Creator:    walletpay.PtrString("creator_user_id"),
    })
    if err != nil {
        log.Fatal(err)
    }
    buf, _ := json.MarshalIndent(order, "", "  ")
    log.Printf(string(buf))
}

import { ApiClient } from "@openweb3-io/wallet-pay";

const ApiKey = "YOUR_API_KEY";
const Secret = "YOUR_SECRET";

const client = new ApiClient(ApiKey, Secret, {});

const USDT = "USDT";
const AMOUNT = "1";

const { decimals } = await client.currencies.findByCode(USDT);

const order = await client.orders.create({
  currency: USDT,
  amount: (BigInt(AMOUNT) * (10n ** BigInt(decimals))).toString(),
  creator: "creator_user_id",
});

console.log(order);

import io.openweb3.walletpay.*;
import io.openweb3.walletpay.models.*;

import java.math.BigInteger;

public class WalletPayExample {
    public static void main(String[] args) {
        String apiKey = "YOUR_API_KEY";
        String secret = "YOUR_SECRET";
        ApiClient apiClient = new ApiClient(
                new ApiClientOptions()
                        .apiKey(apiKey)
                        .privateKey(secret)
        );

        String currencyCode = "USDT";
        String amount = "1"; // readable amount

        // get currency info
        final Currency currency = apiClient.currencies().findByCode(currencyCode);
        System.out.println("currency: " + currency);

        // create order
        BigInteger amountInBaseUnit = new BigInteger(amount).multiply(BigInteger.TEN.pow(currency.getDecimals()));
        CreateOrderRequest orderIn = new CreateOrderRequest()
                .amount(amountInBaseUnit.toString())
                .currency(currencyCode)
                .creator("creator_user_id");
        final Order orderInfo = apiClient.orders().create(orderIn);
        System.out.println("orderInfo: " + orderInfo);

        // list orders
        final PageOrder orders = apiClient.orders().list(
                new OrderListOptions().currency("CoinBeta").size(20)
        );
        System.out.println("orderInfos: " + orders);
    }
}

// example.tsx

const link = `${process.env.TELEGRAM_MANIAPP_DOMAIN}?startapp=Pay_${order_id}`;

sdk.openTelegramLink(link);

import (
    "context"
    "encoding/json"
    "log"
    "math/big"

    walletpay "github.com/openweb3-io/wallet-pay-openapi/go"
)
const ( 
    ApiKey = "YOUR_API_KEY"
    Secret = "YOUR_SECRET"
)

func createRefund() {
    // Initialize ApiClient 
    client := walletpay.New(&walletpay.ApiClientOptions{
        Debug:  true,
        ApiKey: ApiKey,
        Secret: Secret,
    })

    // 1 USDT
    currencyCode := "USDT"
    amount := "1"

    currency, err := client.Currencies.FindByCode(context.Background(), currencyCode)
    if err != nil {
        log.Fatal(err)
    }

    // amountInBaseUnit = amount * 10^decimals
    amountBig, ok := new(big.Int).SetString(amount, 10)
    if !ok {
        log.Fatal("invalid amount")
    }
    
    // 10^decimals
    exp := new(big.Int).Exp(big.NewInt(10), big.NewInt(int64(currency.Decimals)), nil)
    
    // amount * 10^decimals
    amountInBaseUnit := new(big.Int).Mul(amountBig, exp)

    refund, err := client.Refunds.Create(context.Background(), &walletpay.CreateRefundRequest{
        OrderId: "order_123",
        Amount:  amountInBaseUnit.String(),
        Note:    walletpay.PtrString("test"),
    })
    if err != nil {
        log.Fatal(err)
    }

    buf, _ := json.MarshalIndent(refund, "", "  ")
    log.Printf(string(buf))
}

import { ApiClient } from "@openweb3-io/wallet-pay";

const ApiKey = "YOUR_API_KEY";
const Secret = "YOUR_SECRET";

const client = new ApiClient(ApiKey, Secret, {});

const USDT = "USDT";
const AMOUNT = "1";

const { decimals } = await client.currencies.findByCode(USDT);

const refund = await client.refunds.create({
    "orderId": "1234567890",
    "amount": (BigInt(AMOUNT) * (10n ** BigInt(decimals))).toString(),
    "note": "test refund",
});

console.log(refund);

import io.openweb3.walletpay.*;
import io.openweb3.walletpay.models.*;
import java.math.BigInteger;

public class WalletPayExample {
    public static void main(String[] args) {
        String apiKey = "YOUR_API_KEY";
        String secret = "YOUR_SECRET";
        ApiClient apiClient = new ApiClient(
                new ApiClientOptions()
                       .apiKey(apiKey)
                       .privateKey(secret)  
        );

        String currencyCode = "USDT";
        String amount = "1"; // readable amount

        // get currency info
        final Currency currency = apiClient.currencies().findByCode(currencyCode);
        System.out.println("currency: " + currency);

        BigInteger amountInBaseUnit = new BigInteger(amount).multiply(BigInteger.TEN.pow(currency.getDecimals()));
        CreateRefundRequest refundIn = new CreateRefundRequest().
               orderId("order_id").
               amount(amountInBaseUnit.toString());
        Refund refundInfo = apiClient.refunds().create(refundIn);
        System.out.println("refundInfo: " + refundInfo);
    }
}

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

    walletpay "github.com/openweb3-io/wallet-pay-openapi/go"
)

const ( 
    ApiKey = "YOUR_API_KEY"
    Secret = "YOUR_SECRET"
)

func transfer() {
    // Initialize ApiClient 
    client := walletpay.New(&walletpay.ApiClientOptions{
        Debug:  true,
        ApiKey: ApiKey,
        Secret: Secret,
    })

    // 1 USDT
    currencyCode := "USDT"
    amount := "1"

    currency, err := client.Currencies.FindByCode(context.Background(), currencyCode)
    if err != nil {
        log.Fatal(err)
    }

    // amountInBaseUnit = amount * 10^decimals
    amountBig, ok := new(big.Int).SetString(amount, 10)
    if !ok {
        log.Fatal("invalid amount")
    }
    
    // 10^decimals
    exp := new(big.Int).Exp(big.NewInt(10), big.NewInt(int64(currency.Decimals)), nil)
    
    // amount * 10^decimals
    amountInBaseUnit := new(big.Int).Mul(amountBig, exp)

    transfer, err := client.Transfers.Create(context.Background(), &walletpay.TransferRequest{
        Amount:      amountInBaseUnit.String(), 
        Currency:    currencyCode,
        ToWalletId:  "user_wallet_id",
        Description: walletpay.PtrString("Reward redemption"),
    })
    if err != nil {
        log.Fatal(err)
    }

    buf, _ := json.MarshalIndent(transfer, "", "  ")
    log.Printf(string(buf))
}

import { ApiClient } from "@openweb3-io/wallet-pay";

const ApiKey = "YOUR_API_KEY";
const Secret = "YOUR_SECRET";

const client = new ApiClient(ApiKey, Secret, {});

const USDT = "USDT";
const AMOUNT = "1";

const { decimals } = await client.currencies.findByCode(USDT);

const transfer = await client.transfers.transfer({
    amount: (BigInt(AMOUNT) * (10n ** BigInt(decimals))).toString(),
    currency: USDT,
    toWalletId: "user_wallet_id",
    description: "Reward redemption",
});

console.log(transfer);

import io.openweb3.walletpay.*;
import io.openweb3.walletpay.models.*;

import java.math.BigInteger;

public class WalletPayExample {
    public static void main(String[] args) {
        String apiKey = "YOUR_API_KEY";
        String secret = "YOUR_SECRET";
        ApiClient apiClient = new ApiClient(
                new ApiClientOptions()
                        .apiKey(apiKey)
                        .privateKey(secret)
        );

        String currencyCode = "USDT";
        String amount = "1"; // readable amount

        // get currency info
        final Currency currency = apiClient.currencies().findByCode(currencyCode);
        System.out.println("currency: " + currency);

        // transfer funds
        BigInteger amountInBaseUnit = new BigInteger(amount).multiply(BigInteger.TEN.pow(currency.getDecimals()));
        TransferRequest transferIn = new TransferRequest()
                .amount(amountInBaseUnit.toString())
                .currency(currencyCode)
                .toWalletId("user_wallet_id")
                .description("Reward redemption");
        TransferResponse transferInfo = apiClient.transfers().create(transferIn);
        System.out.println("transferInfo: " + transferInfo);
    }
}

import (
    "log"
    walletpay "github.com/openweb3-io/wallet-pay-openapi/go"
)

const (
    publicKey = "YOUR_PUBLIC_KEY"
)

func webhook() {
    client, err := walletpay.NewWebhookClient(publicKey)
    if err != nil {
        log.Fatal(err)
    }

    payload := []byte("content from webhook request body")
    signature := "content from webhook request header: X-Signature"

    // Verify signature
    err = client.Verify(payload, signature)
    if err != nil {
        log.Fatal("signature verify failed")
    } 

    // TODO Signature verification successful, process related business
}

import { WebhookClient } from "@openweb3-io/wallet-pay";

const PUBLICKEY = `-----BEGIN RSA PUBLIC KEY-----
YOUR KEY CONTENT
-----END RSA PUBLIC KEY-----`;

// Request headers with X-Signature and Payload, Verify the signature method
const payload = 'content from webhook request body';
const signature = 'content from webhook request header: X-Signature'
const webhookClient = new WebhookClient(PUBLICKEY);
const result = webhookClient.verify(payload, signature);
if (result) {
  // TODO Signature verification successful, process related business
} else {
  // Signature verification failed, callback is not credible, please ignore
}

import io.openweb3.walletpay.*;

public class WalletPayExample {
    public static void main(String[] args) {
        String publicKey = "YOUR_PUBLIC_KEY";
        String payload = "content from webhook request body";
        String signature = "content from webhook request header: X-Signature";

        // verify the webhook payload
        WebhookClient webhookClient = new WebhookClient(publicKey);
        boolean ok = webhookClient.verify(payload, signature);
        System.out.println("verify " + (ok? "success" : "fail"));
        if (ok) {
            // TODO process the webhook event
        } else {
            // TODO handle the verification failure
        }
    }
}

function verify($data, $publicKey, $signature) {
    // PEM decode (PHP will automatically handle PEM format)
    $pubKey = openssl_pkey_get_public($publicKey);
    if ($pubKey === false) {
        throw new Exception("Public key error: " . openssl_error_string());
    }

    // Base64 decode the signature
    $signBytes = base64_decode($signature, true);
    if ($signBytes === false) {
        error_log("Signature contains invalid characters: $signature");
        throw new Exception("Invalid base64 signature");
    }

    // SHA256 hash calculation
    $hashed = hash('sha256', $data, true);

    // Verify signature
    $result = openssl_verify(
        $hashed, // Use the hashed data for verification
        $signBytes,
        $pubKey,
        OPENSSL_ALGO_SHA256
    );

    // Free key resource
    openssl_free_key($pubKey);

    // Handle verification result
    if ($result === 1) {
        return null; // Verification successful
    } elseif ($result === 0) {
        return new Exception("Invalid signature");
    } else {
        throw new Exception("Verification error: " . openssl_error_string());
    }
}

// Test execution code
try {
    $data = "content from webhook request body";
    $publicKey = "your public key from wallet-pay dashboard";
    $signature = "content from webhook request header: X-Signature";
    
    $result = verify($data, $publicKey, trim($signature));
    
    if ($result === null) {
        echo "verify success\n";
    } else {
        echo "verify failed: " . $result->getMessage() . "\n";
    }
} catch (Exception $e) {
    echo "exception: " . $e->getMessage() . "\n";
}