Smart Contract Interaction

Interact directly with the Paycrest Gateway smart contract for onchain stablecoin-to-fiat (off-ramp) order creation, settlement, and refunds. This approach gives you full control over the blockchain transactions and is ideal for dapps, wallets, or any EVM-compatible application.

This guide uses Viem for smart contract interactions, which is the recommended Ethereum library for modern applications. Viem provides better TypeScript support, improved performance, and a more intuitive API compared to ethers.js.

Starknet, Tron and Solana: this page documents EVM contract calls only. For those networks, use the Sender API Integration with network: "starknet", "tron" or "solana". Tron and Solana orders are created through the v2 Sender API only. Addresses and token contracts are listed under Gateway Contract Addresses and Supported Stablecoins.

Overview

The Gateway contract is a multi-chain EVM-based smart contract that facilitates the onchain lifecycle of payment orders. It empowers users to create off-ramp orders while enabling liquidity providers to facilitate those orders at competitive exchange rates.

Prerequisites

Paycrest Sender Account: Register at app.paycrest.io and complete KYB verification. You’ll need your API Key to embed in every order’s encrypted metadata — this links the onchain order to your sender profile and enables webhooks.
Ethereum Provider: MetaMask, WalletConnect, or any Web3 provider
Viem: For smart contract interactions
USDT/USDC Balance: Sufficient token balance for orders
Gas Fees: ETH for transaction fees

Connect Wallet

JavaScript
Python
Go
cURL

import { createPublicClient, createWalletClient, http, getAddress } from "viem";
import { base } from "viem/chains";

// Connect to user's wallet
const publicClient = createPublicClient({
  chain: base,
  transport: http()
});

const walletClient = await createWalletClient({
  chain: base,
  transport: window.ethereum
});

const [userAddress] = await walletClient.getAddresses();

from web3 import Web3
from eth_account import Account

# Connect to Base network
w3 = Web3(Web3.HTTPProvider('https://mainnet.base.org'))

# For browser integration, you'd typically use a wallet like MetaMask
# This example shows how to connect with a private key
account = Account.from_key('YOUR_PRIVATE_KEY')
user_address = account.address

package main

import (
    "fmt"
    "log"

    "github.com/ethereum/go-ethereum/crypto"
    "github.com/ethereum/go-ethereum/ethclient"
)

func connectWallet() {
    // Connect to Base network
    client, err := ethclient.Dial("https://mainnet.base.org")
    if err != nil {
        log.Fatal(err)
    }

    // Load private key
    privateKey, err := crypto.HexToECDSA("YOUR_PRIVATE_KEY")
    if err != nil {
        log.Fatal(err)
    }

    // Get account address
    publicKey := privateKey.Public()
    publicKeyECDSA, ok := publicKey.(*crypto.PublicKey)
    if !ok {
        log.Fatal("error casting public key to ECDSA")
    }

    userAddress := crypto.PubkeyToAddress(*publicKeyECDSA)
    fmt.Printf("Connected wallet: %s\n", userAddress.Hex())
}

# Wallet connection is typically done in your application code
# rather than with cURL. Use one of the programming language examples above.

Initialize Contracts

JavaScript
Python
Go
cURL

import { getContract } from "viem";

// Gateway contract configuration
const GATEWAY_ADDRESS = "0x30F6A8457F8E42371E204a9c103f2Bd42341dD0F"; // Base
const USDT_ADDRESS = "0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2"; // USDT on Base

// Contract instances
const gateway = getContract({
  address: GATEWAY_ADDRESS,
  abi: GATEWAY_ABI,
  publicClient,
  walletClient
});

const usdt = getContract({
  address: USDT_ADDRESS,
  abi: USDT_ABI,
  publicClient,
  walletClient
});

from web3 import Web3

# Gateway contract configuration
GATEWAY_ADDRESS = "0x30F6A8457F8E42371E204a9c103f2Bd42341dD0F"  # Base
USDT_ADDRESS = "0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2"  # USDT on Base

# Contract instances
gateway = w3.eth.contract(address=GATEWAY_ADDRESS, abi=GATEWAY_ABI)
usdt = w3.eth.contract(address=USDT_ADDRESS, abi=USDT_ABI)

package main

import (
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/ethclient"
)

// Gateway contract configuration
const GATEWAY_ADDRESS = "0x30F6A8457F8E42371E204a9c103f2Bd42341dD0F" // Base
const USDT_ADDRESS = "0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2" // USDT on Base

func initializeContracts(client *ethclient.Client) {
    gatewayAddress := common.HexToAddress(GATEWAY_ADDRESS)
    usdtAddress := common.HexToAddress(USDT_ADDRESS)
    
    // Contract instances would be created with ABI bindings
    // This is a simplified example
    fmt.Printf("Gateway contract: %s\n", gatewayAddress.Hex())
    fmt.Printf("USDT contract: %s\n", usdtAddress.Hex())
}

# Contract initialization is typically done in your application code
# rather than with cURL. Use one of the programming language examples above.

Create an Order

JavaScript
Python
Go
cURL

async function createOffRampOrder(amount, recipient, refundAddress) {
  try {
    const rate = await getExchangeRate();
    const accountName = await verifyAccount(recipient);
    const messageHash = await encryptRecipientData({
      ...recipient,
      accountName,
      metadata: { apiKey: process.env.PAYCREST_API_KEY }
    });
    await approveUSDT(amount);
    const { request } = await gateway.simulate.createOrder({
      args: [
        USDT_ADDRESS,
        parseUnits(amount, 6),
        rate,
        zeroAddress,
        0n,
        refundAddress,
        messageHash
      ]
    });
    
    const hash = await walletClient.writeContract(request);
    const receipt = await publicClient.waitForTransactionReceipt({ hash });
    const orderId = extractOrderId(receipt);
    return { orderId, transactionHash: receipt.hash };
  } catch (error) {
    console.error("Error creating order:", error);
    throw error;
  }
}

async def create_off_ramp_order(amount, recipient, refund_address):
    try:
        rate = await get_exchange_rate()
        account_name = await verify_account(recipient)
        message_hash = await encrypt_recipient_data({
            **recipient,
            'accountName': account_name,
            'metadata': {'apiKey': os.environ['PAYCREST_API_KEY']}
        })
        await approve_usdt(amount)
        
        # Build transaction
        tx = gateway.functions.createOrder(
            USDT_ADDRESS,
            w3.to_wei(amount, 'ether'),
            rate,
            '0x0000000000000000000000000000000000000000',
            0,
            refund_address,
            message_hash
        ).build_transaction({
            'from': user_address,
            'gas': 200000,
            'gasPrice': w3.eth.gas_price,
            'nonce': w3.eth.get_transaction_count(user_address)
        })
        
        # Sign and send transaction
        signed_tx = w3.eth.account.sign_transaction(tx, private_key)
        tx_hash = w3.eth.send_raw_transaction(signed_tx.rawTransaction)
        receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
        
        order_id = extract_order_id(receipt)
        return {'orderId': order_id, 'transactionHash': receipt['transactionHash'].hex()}
    except Exception as error:
        print(f"Error creating order: {error}")
        raise error

func createOffRampOrder(amount string, recipient map[string]interface{}, refundAddress string) error {
    rate, err := getExchangeRate()
    if err != nil {
        return err
    }
    
    accountName, err := verifyAccount(recipient)
    if err != nil {
        return err
    }

    recipient["accountName"] = accountName
    recipient["metadata"] = map[string]interface{}{
        "apiKey": os.Getenv("PAYCREST_API_KEY"),
    }

    messageHash, err := encryptRecipientData(recipient)
    if err != nil {
        return err
    }
    
    err = approveUSDT(amount)
    if err != nil {
        return err
    }
    
    // Build transaction data
    data := buildCreateOrderData(amount, rate, refundAddress, messageHash)
    
    // Create transaction
    tx := &types.Transaction{
        To:       &gatewayAddress,
        Value:    big.NewInt(0),
        Gas:      200000,
        GasPrice: big.NewInt(20000000000), // 20 gwei
        Data:     data,
    }
    
    // Sign and send transaction
    signedTx, err := types.SignTx(tx, types.NewEIP155Signer(big.NewInt(8453)), privateKey)
    if err != nil {
        return err
    }
    
    err = client.SendTransaction(context.Background(), signedTx)
    if err != nil {
        return err
    }
    
    fmt.Printf("Order created with hash: %s\n", signedTx.Hash().Hex())
    return nil
}

# Smart contract interactions are typically done in your application code
# rather than with cURL. Use one of the programming language examples above.

Exchange Rate and Account Verification

For mobile money recipients, you may pass local MSISDN (e.g. KES 07…); POST /v2/verify-account normalizes dial codes server-side. Optional metadata on verify applies for KES Till/Paybill. See Verify Account.

The same rates response also returns data.sell.providerIds—the ranked provider queue for the corridor. Read it alongside rate if you want to carry that queue into the encrypted recipient as providerIds (see Routing fields).

JavaScript
Python
Go
cURL

async function getExchangeRate() {
  const response = await fetch("https://api.paycrest.io/v2/rates/base/usdt/1/ngn");
  const body = await response.json();
  const rateStr = body.data?.sell?.rate ?? body.data?.buy?.rate;
  return rateStr != null ? Number(rateStr) : NaN;
}

async function verifyAccount(recipient) {
  const response = await fetch("https://api.paycrest.io/v2/verify-account", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      institution: recipient.institution,
      accountIdentifier: recipient.accountIdentifier
    })
  });
  const data = await response.json();
  return data.data;
}

import requests

async def get_exchange_rate():
    response = requests.get("https://api.paycrest.io/v2/rates/base/usdt/1/ngn")
    data = response.json()
    d = data.get("data") or {}
    side = d.get("sell") or d.get("buy") or {}
    rate = side.get("rate")
    return float(rate) if rate is not None else float("nan")

async def verify_account(recipient):
    response = requests.post(
        "https://api.paycrest.io/v2/verify-account",
        headers={"Content-Type": "application/json"},
        json={
            "institution": recipient["institution"],
            "accountIdentifier": recipient["accountIdentifier"]
        }
    )
    data = response.json()
    return data['data']

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "strconv"
)

func getExchangeRate() (float64, error) {
    resp, err := http.Get("https://api.paycrest.io/v2/rates/base/usdt/1/ngn")
    if err != nil {
        return 0, err
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return 0, err
    }

    var result struct {
        Data struct {
            Sell *struct {
                Rate string `json:"rate"`
            } `json:"sell"`
            Buy *struct {
                Rate string `json:"rate"`
            } `json:"buy"`
        } `json:"data"`
    }
    if err := json.Unmarshal(body, &result); err != nil {
        return 0, err
    }
    var rateStr string
    if result.Data.Sell != nil {
        rateStr = result.Data.Sell.Rate
    } else if result.Data.Buy != nil {
        rateStr = result.Data.Buy.Rate
    }
    if rateStr == "" {
        return 0, fmt.Errorf("no rate in response")
    }
    return strconv.ParseFloat(rateStr, 64)
}

func verifyAccount(recipient map[string]interface{}) (string, error) {
    jsonData, _ := json.Marshal(map[string]interface{}{
        "institution":       recipient["institution"],
        "accountIdentifier": recipient["accountIdentifier"],
    })
    
    resp, err := http.Post(
        "https://api.paycrest.io/v2/verify-account",
        "application/json",
        bytes.NewBuffer(jsonData),
    )
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()
    
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return "", err
    }
    
    var result map[string]interface{}
    json.Unmarshal(body, &result)
    
    return result["data"].(string), nil
}

# Get exchange rate (see data.sell.rate / data.buy.rate in JSON)
curl -X GET "https://api.paycrest.io/v2/rates/base/usdt/1/ngn"

# Verify account
curl -X POST "https://api.paycrest.io/v2/verify-account" \
  -H "Content-Type: application/json" \
  -d '{
    "institution": "GTB",
    "accountIdentifier": "1234567890"
  }'

Data Encryption

The recipient object is encrypted with the aggregator’s public key to produce the messageHash passed to the contract. Always include your API Key in the metadata.apiKey field — this is the same key used as the API-Key header in REST requests, and it links the onchain order to your sender profile, enabling webhooks and order attribution.

Your API Key is available in the dashboard at app.paycrest.io.

On EVM networks you can additionally (or instead) attribute orders with an onchain ERC-8021 data suffix. See Onchain Attribution (ERC-8021).

Routing fields

The recipient object may carry routing hints—this is the only channel for them onchain, since createOrder has no provider argument:

Field	Description
`providerIds`	Ordered provider queue (max 3). Assignment tries entries in order. Typically the ids from `GET /v2/rates`. A one-entry queue routes to a single provider.
`providerId`	Single provider, 8 alphabetic characters. Retained for backward compatibility—prefer `providerIds`.

The two are mutually exclusive. A hash carrying both is not rejected—the queue wins and providerId is ignored. A queue whose entries can’t serve the corridor is dropped silently and the order routes as unpinned; there is no onchain rejection and no error webhook, so validate ids against a rate quote before encrypting. Omit both and the aggregator resolves a queue itself at order creation. Entries in a multi-entry queue must name providers that can serve the corridor—active, with a live standard offer, and, for a provider restricted to specific senders, one whose list includes the sender resolved from metadata.apiKey. A one-entry queue is simply a pin. The fallback provider may be listed but is ignored.

Budget ~450 bytes for recipient data. MESSAGE_HASH_MAX_SIZE caps the recipient JSON at 500 bytes, measured before encryption. The size check reserves room for a full 3-provider queue on every order—including orders that send no providerIds—because the aggregator may resolve one onto the order, and it rides in the message hash at gateway submit.That reservation costs about 49 bytes (~41 if you pin a providerId), leaving roughly 450 bytes for accountIdentifier + accountName + memo + metadata combined. Exceeding it returns 400 with "Recipient data too large for encryption". Trim memo and metadata first—see Troubleshooting.

Reading a hash the aggregator produced: queued orders publish "ProviderID": "" plus a ProviderIDs array. Anything downstream that parses ProviderID must fall back to ProviderIDs[0]. Keys decode case-insensitively, so providerIds and ProviderIDs are equivalent on the way in.

JavaScript
Python
Go
cURL

async function encryptRecipientData(recipient) {
  const response = await fetch("https://api.paycrest.io/v2/pubkey");
  const { data: publicKey } = await response.json();
  const encrypt = new JSEncrypt();
  encrypt.setPublicKey(publicKey);
  const encrypted = encrypt.encrypt(JSON.stringify(recipient));
  if (!encrypted) {
    throw new Error("Failed to encrypt recipient data");
  }
  return encrypted;
}

import requests
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
import json
import base64

async def encrypt_recipient_data(recipient):
    response = requests.get("https://api.paycrest.io/v2/pubkey")
    public_key = response.json()['data']
    
    # Import public key
    key = RSA.import_key(public_key)
    cipher = PKCS1_OAEP.new(key)
    
    # Encrypt recipient data
    recipient_json = json.dumps(recipient)
    encrypted = cipher.encrypt(recipient_json.encode('utf-8'))
    encrypted_b64 = base64.b64encode(encrypted).decode('utf-8')
    
    return encrypted_b64

import (
    "crypto/rand"
    "crypto/rsa"
    "crypto/x509"
    "encoding/base64"
    "encoding/json"
    "encoding/pem"
    "fmt"
    "io"
    "net/http"
)

func encryptRecipientData(recipient map[string]interface{}) (string, error) {
    // Get public key
    resp, err := http.Get("https://api.paycrest.io/v2/pubkey")
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()
    
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return "", err
    }
    
    var result map[string]interface{}
    json.Unmarshal(body, &result)
    publicKeyPEM := result["data"].(string)
    
    // Parse public key
    block, _ := pem.Decode([]byte(publicKeyPEM))
    if block == nil {
        return "", fmt.Errorf("failed to parse public key")
    }
    
    pubKey, err := x509.ParsePKIXPublicKey(block.Bytes)
    if err != nil {
        return "", err
    }
    
    rsaPubKey, ok := pubKey.(*rsa.PublicKey)
    if !ok {
        return "", fmt.Errorf("not an RSA public key")
    }
    
    // Encrypt recipient data
    recipientJSON, _ := json.Marshal(recipient)
    encrypted, err := rsa.EncryptPKCS1v15(rand.Reader, rsaPubKey, recipientJSON)
    if err != nil {
        return "", err
    }
    
    return base64.StdEncoding.EncodeToString(encrypted), nil
}

# Get public key for encryption
curl -X GET "https://api.paycrest.io/v2/pubkey"

# Note: Encryption is typically done in your application code
# rather than with cURL. Use one of the programming language examples above.

Onchain Attribution (ERC-8021)

Paycrest tags EVM transactions with an ERC-8021 schema-0 data suffix that carries a sender’s trading name as a public, human-readable attribution tag. The suffix is execution-inert: the Gateway contract ignores trailing bytes beyond its expected ABI arguments, so it passes through without affecting execution. Cost is roughly 16 gas per non-zero byte.

The suffix is public attribution only. It is not read for sender identification. Sender resolution, webhook delivery, and order lookup use metadata.apiKey inside the encrypted messageHash, which remains the authoritative and only mechanism.

Who appends the suffix

Path	Who appends it	Code used
Sender API (aggregator-relayed orders)	The aggregator, automatically	The sender’s KYB trading name
Direct Gateway integration (this guide)	You, on your own `createOrder` calldata	Whatever you choose to publish
Noblocks on Base mainnet	The Noblocks app	Its registered Base Builder Code

On the Sender API path the aggregator appends the suffix to the transactions it submits for an order: creation, settlement, and refunds. Senders with no trading name on their KYB profile get no suffix. There is nothing to configure. If you call the Gateway contract directly, nothing is appended for you. The rest of this section covers appending your own.

Your sender code

Pick a printable-ASCII code that identifies you publicly. Paycrest uses the trading name from the KYB profile for its own attribution, so matching that keeps your direct transactions consistent with your Sender API ones.

// Your trading name from your KYB profile at app.paycrest.io
const senderCode = "AcmeCorp";

Whatever you put in the suffix is permanently public onchain. Use a business identifier you are happy to publish. Never place an API secret, key ID, or any credential in the suffix: your API secret stays for webhooks and REST authentication only.

Suffix layout

Schema 0, parsed backwards from the end of the calldata:

Field	Size	Value
`codes`	variable	Comma-joined ASCII codes
`length`	1 byte	Byte length of `codes`
`schemaId`	1 byte	`0x00`
`marker`	16 bytes	`0x8021` repeated 8 times

Constraints: codes must be non-empty printable ASCII (0x20 to 0x7e), individual codes must not contain a comma (the delimiter), and the joined string must be at most 255 bytes. Violating any of these makes the suffix unparseable by ERC-8021 readers. It has no effect on your order, which is processed from metadata.apiKey either way. Worked example for trading name AcmeCorp:

41636d65436f7270 08 00 80218021802180218021802180218021
└── "AcmeCorp" ──┘ len schema        marker
                  0x08  0x00

Encoding the suffix

JavaScript
Python
Go
cURL

import { concatHex, stringToHex, toHex } from "viem";

const ERC8021_MARKER = `0x${"8021".repeat(8)}`;

function encodeAttributionSuffix(codes) {
  for (const code of codes) {
    if (!code || code.includes(",")) {
      throw new Error("ERC-8021 codes must be non-empty and comma-free");
    }
  }
  const joined = codes.join(",");
  if (!joined || joined.length > 255) {
    throw new Error("ERC-8021 codes must be 1-255 bytes once joined");
  }
  for (let i = 0; i < joined.length; i++) {
    const c = joined.charCodeAt(i);
    if (c < 0x20 || c > 0x7e) {
      throw new Error("ERC-8021 codes must be printable ASCII");
    }
  }
  return concatHex([
    stringToHex(joined),
    toHex(joined.length, { size: 1 }),
    "0x00",
    ERC8021_MARKER,
  ]);
}

ERC8021_MARKER = bytes.fromhex("8021" * 8)

def encode_attribution_suffix(codes):
    for code in codes:
        if not code or "," in code:
            raise ValueError("ERC-8021 codes must be non-empty and comma-free")
    joined = ",".join(codes)
    if not joined or len(joined) > 255:
        raise ValueError("ERC-8021 codes must be 1-255 bytes once joined")
    encoded = joined.encode("ascii")
    if any(b < 0x20 or b > 0x7e for b in encoded):
        raise ValueError("ERC-8021 codes must be printable ASCII")
    return encoded + bytes([len(encoded), 0x00]) + ERC8021_MARKER

import (
    "fmt"
    "strings"

    "github.com/ethereum/go-ethereum/common"
)

var erc8021Marker = common.Hex2Bytes("80218021802180218021802180218021")

func encodeAttributionSuffix(codes []string) ([]byte, error) {
    for _, code := range codes {
        if code == "" || strings.Contains(code, ",") {
            return nil, fmt.Errorf("ERC-8021 codes must be non-empty and comma-free")
        }
    }
    joined := strings.Join(codes, ",")
    if joined == "" || len(joined) > 255 {
        return nil, fmt.Errorf("ERC-8021 codes must be 1-255 bytes once joined")
    }
    for i := 0; i < len(joined); i++ {
        if joined[i] < 0x20 || joined[i] > 0x7e {
            return nil, fmt.Errorf("ERC-8021 codes must be printable ASCII")
        }
    }
    out := make([]byte, 0, len(joined)+2+len(erc8021Marker))
    out = append(out, joined...)
    out = append(out, byte(len(joined)), 0x00)
    out = append(out, erc8021Marker...)
    return out, nil
}

# Suffix encoding is a calldata construction step and has no cURL equivalent.
# Use one of the programming language examples above.

Appending to createOrder

The suffix must be appended to the calldata before signing and gas estimation so it is covered by the signature and paid for in the gas limit. Keep sending metadata.apiKey: the suffix is additive, not a replacement.

Viem’s writeContract and simulate helpers build calldata internally and give you no place to append raw bytes. To attach a suffix, encode the call yourself with encodeFunctionData and send it with sendTransaction.

JavaScript
Python
Go
cURL

import { concatHex, encodeFunctionData, parseUnits, zeroAddress } from "viem";

async function createOffRampOrderAttributed(amount, recipient, refundAddress) {
  const rate = await getExchangeRate();
  const accountName = await verifyAccount(recipient);
  const messageHash = await encryptRecipientData({
    ...recipient,
    accountName,
    // Required: this is how the aggregator identifies you. The suffix does not replace it.
    metadata: { apiKey: process.env.PAYCREST_API_KEY },
  });
  await approveUSDT(amount);

  const callData = encodeFunctionData({
    abi: GATEWAY_ABI,
    functionName: "createOrder",
    args: [
      USDT_ADDRESS,
      parseUnits(amount, 6),
      rate,
      zeroAddress,
      0n,
      refundAddress,
      messageHash,
    ],
  });

  const senderCode = "AcmeCorp"; // Your public attribution code
  const data = concatHex([callData, encodeAttributionSuffix([senderCode])]);

  const hash = await walletClient.sendTransaction({
    to: GATEWAY_ADDRESS,
    data,
  });
  const receipt = await publicClient.waitForTransactionReceipt({ hash });
  return { orderId: extractOrderId(receipt), transactionHash: receipt.transactionHash };
}

tx = gateway.functions.createOrder(
    USDT_ADDRESS,
    w3.to_wei(amount, 'ether'),
    rate,
    '0x0000000000000000000000000000000000000000',
    0,
    refund_address,
    message_hash
).build_transaction({
    'from': user_address,
    'nonce': w3.eth.get_transaction_count(user_address),
})

sender_code = "AcmeCorp"  # Your public attribution code
tx['data'] = tx['data'] + encode_attribution_suffix([sender_code]).hex()

# Estimate gas AFTER appending so the suffix is covered.
tx['gas'] = w3.eth.estimate_gas(tx)
tx['gasPrice'] = w3.eth.gas_price

signed_tx = w3.eth.account.sign_transaction(tx, private_key)
tx_hash = w3.eth.send_raw_transaction(signed_tx.rawTransaction)

callData, err := gatewayABI.Pack(
    "createOrder",
    tokenAddress, amount, rate, senderFeeRecipient, senderFee, refundAddress, messageHash,
)
if err != nil {
    return err
}

senderCode := "AcmeCorp" // Your public attribution code
suffix, err := encodeAttributionSuffix([]string{senderCode})
if err != nil {
    return err
}
data := append(callData, suffix...)

// Estimate gas against the suffixed calldata.
gasLimit, err := client.EstimateGas(ctx, ethereum.CallMsg{
    From: fromAddress,
    To:   &gatewayAddress,
    Data: data,
})

# Smart contract interactions are typically done in your application code
# rather than with cURL. Use one of the programming language examples above.

Where the suffix must live

ERC-8021 readers parse the outer transaction calldata backwards from its final byte, so the suffix has to be the last thing in the top-level input.

EOA senders: append to tx.data.
Account abstraction / smart accounts: append to the outer userOp.callData, the top-level input that lands onchain.
Do not bury the suffix inside a nested or inner call. A suffix on an inner call is invisible to the parser, because ABI encoding pads inner bytes fields and the outer calldata will not end with the marker.

Anything that appends bytes after your suffix breaks parsing too, since only the trailing suffix is read.

Codes and the Base Builder Code

The codes field is a list, so a transaction can carry more than one code, comma-joined. For direct integrators the default is your own code alone, on every EVM network including Base.

bc_julg9gbq is Paycrest/Noblocks’ own registered Base Builder Code, appended by the Noblocks app on Base mainnet for base.dev analytics and rewards. It identifies Noblocks as the originating app. Do not include it in your own transactions unless you have an explicit co-branding arrangement with Paycrest: it is not a code for arbitrary senders to claim.

Relationship to `metadata.apiKey`

metadata.apiKey is unchanged, not deprecated, and remains the single mechanism by which the aggregator identifies the sender behind an order. Keep sending it exactly as before.

Present	Sender resolution
`metadata.apiKey` only	`metadata.apiKey`
Onchain suffix only	Order is not attributed to a sender. The suffix is not read for identification
Both	`metadata.apiKey`
Suffix malformed or absent	No effect: resolution uses `metadata.apiKey`

Appending a suffix does not replace metadata.apiKey. An order created with a suffix but without metadata.apiKey will not be linked to your sender profile, and you will not receive webhooks for it.

Adding a suffix can never break order indexing. A malformed suffix, an unrecognized code, or no suffix at all leaves order processing untouched.

Network support

Onchain attribution applies to EVM networks only. On Starknet no suffix is appended or read, and attribution works from metadata.apiKey exclusively. References: ERC-8021 specification

Token Approval

JavaScript
Python
Go
cURL

async function approveUSDT(amount) {
  const usdtAmount = parseUnits(amount, 6);
  const allowance = await usdt.read.allowance([userAddress, GATEWAY_ADDRESS]);
  if (allowance < usdtAmount) {
    const { request } = await usdt.simulate.approve({
      args: [GATEWAY_ADDRESS, usdtAmount]
    });
    const hash = await walletClient.writeContract(request);
    await publicClient.waitForTransactionReceipt({ hash });
  }
}

async def approve_usdt(amount):
    usdt_amount = w3.to_wei(amount, 'ether')
    allowance = usdt.functions.allowance(user_address, GATEWAY_ADDRESS).call()
    
    if allowance < usdt_amount:
        tx = usdt.functions.approve(
            GATEWAY_ADDRESS, 
            usdt_amount
        ).build_transaction({
            'from': user_address,
            'gas': 100000,
            'gasPrice': w3.eth.gas_price,
            'nonce': w3.eth.get_transaction_count(user_address)
        })
        
        signed_tx = w3.eth.account.sign_transaction(tx, private_key)
        tx_hash = w3.eth.send_raw_transaction(signed_tx.rawTransaction)
        w3.eth.wait_for_transaction_receipt(tx_hash)

func approveUSDT(amount string) error {
    usdtAmount := new(big.Int)
    usdtAmount.SetString(amount, 10)
    usdtAmount.Mul(usdtAmount, new(big.Int).Exp(big.NewInt(10), big.NewInt(6), nil)) // USDT has 6 decimals
    
    // Check current allowance
    allowance, err := usdtContract.Allowance(nil, userAddress, gatewayAddress)
    if err != nil {
        return err
    }
    
    if allowance.Cmp(usdtAmount) < 0 {
        // Build approve transaction
        data := buildApproveData(gatewayAddress, usdtAmount)
        
        tx := &types.Transaction{
            To:       &usdtAddress,
            Value:    big.NewInt(0),
            Gas:      100000,
            GasPrice: big.NewInt(20000000000), // 20 gwei
            Data:     data,
        }
        
        // Sign and send transaction
        signedTx, err := types.SignTx(tx, types.NewEIP155Signer(big.NewInt(8453)), privateKey)
        if err != nil {
            return err
        }
        
        err = client.SendTransaction(context.Background(), signedTx)
        if err != nil {
            return err
        }
        
        fmt.Printf("USDT approved with hash: %s\n", signedTx.Hash().Hex())
    }
    
    return nil
}

# Token approval is typically done in your application code
# rather than with cURL. Use one of the programming language examples above.

Get Order Information

JavaScript
Python
Go
cURL

async function getOrderInfo(orderId) {
  const orderInfo = await gateway.read.getOrderInfo([orderId]);
  return {
    sender: orderInfo.sender,
    token: orderInfo.token,
    amount: formatUnits(orderInfo.amount, 6),
    isFulfilled: orderInfo.isFulfilled,
    isRefunded: orderInfo.isRefunded,
    refundAddress: orderInfo.refundAddress
  };
}

def get_order_info(order_id):
    order_info = gateway.functions.getOrderInfo(order_id).call()
    return {
        'sender': order_info[0],
        'token': order_info[1],
        'amount': w3.from_wei(order_info[2], 'ether'),
        'isFulfilled': order_info[3],
        'isRefunded': order_info[4],
        'refundAddress': order_info[5]
    }

func getOrderInfo(orderID string) (map[string]interface{}, error) {
    orderInfo, err := gatewayContract.GetOrderInfo(nil, orderID)
    if err != nil {
        return nil, err
    }
    
    amount := new(big.Float).Quo(
        new(big.Float).SetInt(orderInfo.Amount),
        new(big.Float).SetInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(6), nil)),
    )
    
    return map[string]interface{}{
        "sender":        orderInfo.Sender.Hex(),
        "token":         orderInfo.Token.Hex(),
        "amount":        amount.Text('f', 6),
        "isFulfilled":   orderInfo.IsFulfilled,
        "isRefunded":    orderInfo.IsRefunded,
        "refundAddress": orderInfo.RefundAddress.Hex(),
    }, nil
}

# Get order information from blockchain
# This requires a Web3 provider and contract interaction
# Use one of the programming language examples above.

Event Listening

JavaScript
Python
Go
cURL

// Listen for events using viem's watchContractEvent
const unwatchOrderCreated = publicClient.watchContractEvent({
  address: GATEWAY_ADDRESS,
  abi: GATEWAY_ABI,
  eventName: 'OrderCreated',
  onLogs: (logs) => {
    logs.forEach((log) => {
      console.log("Order Created:", {
        sender: log.args.sender,
        token: log.args.token,
        amount: formatUnits(log.args.amount, 6),
        orderId: log.args.orderId,
        rate: log.args.rate
      });
    });
  }
});

const unwatchSettleOut = publicClient.watchContractEvent({
  address: GATEWAY_ADDRESS,
  abi: GATEWAY_ABI,
  eventName: 'SettleOut',
  onLogs: (logs) => {
    logs.forEach((log) => {
      console.log("Order Settled (SettleOut):", { 
        orderId: log.args.orderId, 
        liquidityProvider: log.args.liquidityProvider, 
        settlePercent: log.args.settlePercent 
      });
    });
  }
});

const unwatchOrderRefunded = publicClient.watchContractEvent({
  address: GATEWAY_ADDRESS,
  abi: GATEWAY_ABI,
  eventName: 'OrderRefunded',
  onLogs: (logs) => {
    logs.forEach((log) => {
      console.log("Order Refunded:", { 
        fee: formatUnits(log.args.fee, 6), 
        orderId: log.args.orderId 
      });
    });
  }
});

from web3.middleware import geth_poa_middleware
import asyncio

# Add middleware for Base network
w3.middleware_onion.inject(geth_poa_middleware, layer=0)

def handle_order_created(event):
    print("Order Created:", {
        'sender': event['args']['sender'],
        'token': event['args']['token'],
        'amount': w3.from_wei(event['args']['amount'], 'ether'),
        'orderId': event['args']['orderId'],
        'rate': event['args']['rate']
    })

def handle_settle_out(event):
    print("Order Settled (SettleOut):", {
        'orderId': event['args']['orderId'],
        'liquidityProvider': event['args']['liquidityProvider'],
        'settlePercent': event['args']['settlePercent']
    })

def handle_order_refunded(event):
    print("Order Refunded:", {
        'fee': w3.from_wei(event['args']['fee'], 'ether'),
        'orderId': event['args']['orderId']
    })

# Create event filters
order_created_filter = gateway.events.OrderCreated.create_filter(fromBlock='latest')
settle_out_filter = gateway.events.SettleOut.create_filter(fromBlock='latest')
order_refunded_filter = gateway.events.OrderRefunded.create_filter(fromBlock='latest')

# Poll for events
async def poll_events():
    while True:
        for event in order_created_filter.get_new_entries():
            handle_order_created(event)
        for event in settle_out_filter.get_new_entries():
            handle_settle_out(event)
        for event in order_refunded_filter.get_new_entries():
            handle_order_refunded(event)
        await asyncio.sleep(1)

import (
    "context"
    "fmt"
    "log"
    "time"

    "github.com/ethereum/go-ethereum"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core/types"
)

func watchEvents(client *ethclient.Client) {
    // Create event filters
    orderCreatedSig := []byte("OrderCreated(address,address,uint256,bytes32,uint256)")
    settleOutSig := []byte("SettleOut(bytes32,bytes32,address,uint64,uint64)")
    orderRefundedSig := []byte("OrderRefunded(uint256,bytes32)")
    
    orderCreatedSigHash := crypto.Keccak256(orderCreatedSig)
    settleOutSigHash := crypto.Keccak256(settleOutSig)
    orderRefundedSigHash := crypto.Keccak256(orderRefundedSig)
    
    query := ethereum.FilterQuery{
        Addresses: []common.Address{gatewayAddress},
        Topics: [][]common.Hash{
            {common.BytesToHash(orderCreatedSigHash), common.BytesToHash(settleOutSigHash), common.BytesToHash(orderRefundedSigHash)},
        },
    }
    
    logs := make(chan types.Log)
    sub, err := client.SubscribeFilterLogs(context.Background(), query, logs)
    if err != nil {
        log.Fatal(err)
    }
    
    for {
        select {
        case err := <-sub.Err():
            log.Fatal(err)
        case vLog := <-logs:
            if vLog.Topics[0] == common.BytesToHash(orderCreatedSigHash) {
                handleOrderCreated(vLog)
            } else if vLog.Topics[0] == common.BytesToHash(settleOutSigHash) {
                handleSettleOut(vLog)
            } else if vLog.Topics[0] == common.BytesToHash(orderRefundedSigHash) {
                handleOrderRefunded(vLog)
            }
        }
    }
}

func handleOrderCreated(log types.Log) {
    fmt.Printf("Order Created: %+v\n", log)
}

func handleSettleOut(log types.Log) {
    fmt.Printf("Order Settled (SettleOut): %+v\n", log)
}

func handleOrderRefunded(log types.Log) {
    fmt.Printf("Order Refunded: %+v\n", log)
}

# Event listening is typically done in your application code
# rather than with cURL. Use one of the programming language examples above.

Error Handling

JavaScript
Python
Go
cURL

function handleContractError(error) {
  if (error.code === 4001) {
    throw new Error("User rejected transaction");
  } else if (error.message.includes("insufficient funds")) {
    throw new Error("Insufficient USDT balance or ETH for gas");
  } else if (error.message.includes("execution reverted")) {
    throw new Error("Transaction reverted - check parameters");
  } else {
    throw new Error(`Contract error: ${error.message}`);
  }
}

async function retryTransaction(txFunction, maxRetries = 3) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await txFunction();
    } catch (error) {
      if (attempt === maxRetries) throw error;
      await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
    }
  }
}

def handle_contract_error(error):
    if "user rejected" in str(error).lower():
        raise Exception("User rejected transaction")
    elif "insufficient funds" in str(error).lower():
        raise Exception("Insufficient USDT balance or ETH for gas")
    elif "execution reverted" in str(error).lower():
        raise Exception("Transaction reverted - check parameters")
    else:
        raise Exception(f"Contract error: {str(error)}")

async def retry_transaction(tx_function, max_retries=3):
    for attempt in range(1, max_retries + 1):
        try:
            return await tx_function()
        except Exception as error:
            if attempt == max_retries:
                raise error
            await asyncio.sleep(1000 * attempt)

import (
    "fmt"
    "strings"
    "time"
)

func handleContractError(err error) error {
    errStr := strings.ToLower(err.Error())
    if strings.Contains(errStr, "user rejected") {
        return fmt.Errorf("user rejected transaction")
    } else if strings.Contains(errStr, "insufficient funds") {
        return fmt.Errorf("insufficient USDT balance or ETH for gas")
    } else if strings.Contains(errStr, "execution reverted") {
        return fmt.Errorf("transaction reverted - check parameters")
    } else {
        return fmt.Errorf("contract error: %v", err)
    }
}

func retryTransaction(txFunction func() error, maxRetries int) error {
    for attempt := 1; attempt <= maxRetries; attempt++ {
        err := txFunction()
        if err == nil {
            return nil
        }
        
        if attempt == maxRetries {
            return err
        }
        
        time.Sleep(time.Duration(1000*attempt) * time.Millisecond)
    }
    return fmt.Errorf("max retries exceeded")
}

# Error handling is typically done in your application code
# rather than with cURL. Use one of the programming language examples above.

Complete Example

JavaScript
Python
Go
cURL

import { parseUnits, formatUnits, zeroAddress } from "viem";

class PaycrestGateway {
  constructor(publicClient, walletClient, gatewayAddress, usdtAddress) {
    this.provider = publicClient;
    this.walletClient = walletClient;
    this.gatewayAddress = gatewayAddress;
    this.usdtAddress = usdtAddress;
    this.gateway = null;
    this.usdt = null;
  }

  async initialize() {
    this.gateway = getContract({
      address: this.gatewayAddress,
      abi: GATEWAY_ABI,
      publicClient: this.provider,
      walletClient: this.walletClient
    });
    this.usdt = getContract({
      address: this.usdtAddress,
      abi: USDT_ABI,
      publicClient: this.provider,
      walletClient: this.walletClient
    });
    this.setupEventListeners();
  }

  setupEventListeners() {
    this.provider.watchContractEvent({
      address: this.gatewayAddress,
      abi: GATEWAY_ABI,
      eventName: 'OrderCreated',
      onLogs: this.handleOrderCreated.bind(this)
    });
    this.provider.watchContractEvent({
      address: this.gatewayAddress,
      abi: GATEWAY_ABI,
      eventName: 'SettleOut',
      onLogs: this.handleSettleOut.bind(this)
    });
    this.provider.watchContractEvent({
      address: this.gatewayAddress,
      abi: GATEWAY_ABI,
      eventName: 'OrderRefunded',
      onLogs: this.handleOrderRefunded.bind(this)
    });
  }

  async createOrder(amount, recipient, refundAddress) {
    try {
      const rate = await this.getExchangeRate();
      const accountName = await this.verifyAccount(recipient);
      const messageHash = await this.encryptRecipientData({ ...recipient, accountName });
      await this.approveUSDT(amount);
      const { request } = await this.gateway.simulate.createOrder({
        args: [
          this.usdtAddress,
          parseUnits(amount, 6),
          rate,
          zeroAddress,
          0n,
          refundAddress,
          messageHash
        ]
      });
      const hash = await this.walletClient.writeContract(request);
      const receipt = await this.provider.waitForTransactionReceipt({ hash });
      return { orderId: this.extractOrderId(receipt), hash: receipt.hash };
    } catch (error) {
      handleContractError(error);
    }
  }
  // ... other methods (getExchangeRate, verifyAccount, etc.)
}

// Usage
const paycrest = new PaycrestGateway(
  publicClient,
  walletClient,
  "0xE8bc3B607CfE68F47000E3d200310D49041148Fc",
  "0xdac17f958d2ee523a2206206994597c13d831ec7"
);

await paycrest.initialize();

const order = await paycrest.createOrder(
  "100", // USDT amount
  {
    institution: "GTBINGLA",
    accountIdentifier: "123456789"
  },
  "0x123..." // Refund address
);

from web3 import Web3
from eth_account import Account
import asyncio

class PaycrestGateway:
    def __init__(self, w3, gateway_address, usdt_address):
        self.w3 = w3
        self.gateway_address = gateway_address
        self.usdt_address = usdt_address
        self.gateway = None
        self.usdt = None
        
    async def initialize(self):
        self.gateway = self.w3.eth.contract(
            address=self.gateway_address, 
            abi=GATEWAY_ABI
        )
        self.usdt = self.w3.eth.contract(
            address=self.usdt_address, 
            abi=USDT_ABI
        )
        self.setup_event_listeners()
        
    def setup_event_listeners(self):
        # Event listeners would be set up here
        pass
        
    async def create_order(self, amount, recipient, refund_address):
        try:
            rate = await self.get_exchange_rate()
            account_name = await self.verify_account(recipient)
            message_hash = await self.encrypt_recipient_data({**recipient, 'accountName': account_name})
            await self.approve_usdt(amount)
            
            tx = self.gateway.functions.createOrder(
                self.usdt_address,
                self.w3.to_wei(amount, 'ether'),
                rate,
                '0x0000000000000000000000000000000000000000',
                0,
                refund_address,
                message_hash
            ).build_transaction({
                'from': user_address,
                'gas': 200000,
                'gasPrice': self.w3.eth.gas_price,
                'nonce': self.w3.eth.get_transaction_count(user_address)
            })
            
            signed_tx = self.w3.eth.account.sign_transaction(tx, private_key)
            tx_hash = self.w3.eth.send_raw_transaction(signed_tx.rawTransaction)
            receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash)
            
            return {'orderId': self.extract_order_id(receipt), 'hash': receipt['transactionHash'].hex()}
        except Exception as error:
            handle_contract_error(error)
            
    # ... other methods (get_exchange_rate, verify_account, etc.)

# Usage
w3 = Web3(Web3.HTTPProvider('https://mainnet.base.org'))
paycrest = PaycrestGateway(
    w3,
    "0xE8bc3B607CfE68F47000E3d200310D49041148Fc",
    "0xdac17f958d2ee523a2206206994597c13d831ec7"
)

await paycrest.initialize()

order = await paycrest.create_order(
    "100",  # USDT amount
    {
        "institution": "GTBINGLA",
        "accountIdentifier": "123456789"
    },
    "0x123..."  # Refund address
)

package main

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

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/ethclient"
)

type PaycrestGateway struct {
    client         *ethclient.Client
    gatewayAddress common.Address
    usdtAddress    common.Address
    gateway        *GatewayContract
    usdt           *USDTContract
}

func NewPaycrestGateway(client *ethclient.Client, gatewayAddr, usdtAddr string) *PaycrestGateway {
    return &PaycrestGateway{
        client:         client,
        gatewayAddress: common.HexToAddress(gatewayAddr),
        usdtAddress:    common.HexToAddress(usdtAddr),
    }
}

func (pg *PaycrestGateway) Initialize() error {
    // Initialize contracts with ABI bindings
    gateway, err := NewGatewayContract(pg.gatewayAddress, pg.client)
    if err != nil {
        return err
    }
    pg.gateway = gateway
    
    usdt, err := NewUSDTContract(pg.usdtAddress, pg.client)
    if err != nil {
        return err
    }
    pg.usdt = usdt
    
    pg.setupEventListeners()
    return nil
}

func (pg *PaycrestGateway) setupEventListeners() {
    // Event listeners would be set up here
}

func (pg *PaycrestGateway) CreateOrder(amount string, recipient map[string]interface{}, refundAddress string) error {
    rate, err := pg.getExchangeRate()
    if err != nil {
        return err
    }
    
    accountName, err := pg.verifyAccount(recipient)
    if err != nil {
        return err
    }
    
    messageHash, err := pg.encryptRecipientData(recipient, accountName)
    if err != nil {
        return err
    }
    
    err = pg.approveUSDT(amount)
    if err != nil {
        return err
    }
    
    // Build transaction data
    data := pg.buildCreateOrderData(amount, rate, refundAddress, messageHash)
    
    // Create transaction
    tx := &types.Transaction{
        To:       &pg.gatewayAddress,
        Value:    big.NewInt(0),
        Gas:      200000,
        GasPrice: big.NewInt(20000000000), // 20 gwei
        Data:     data,
    }
    
    // Sign and send transaction
    signedTx, err := types.SignTx(tx, types.NewEIP155Signer(big.NewInt(8453)), privateKey)
    if err != nil {
        return err
    }
    
    err = pg.client.SendTransaction(context.Background(), signedTx)
    if err != nil {
        return err
    }
    
    fmt.Printf("Order created with hash: %s\n", signedTx.Hash().Hex())
    return nil
}

// Usage
func main() {
    client, err := ethclient.Dial("https://mainnet.base.org")
    if err != nil {
        log.Fatal(err)
    }
    
    paycrest := NewPaycrestGateway(
        client,
        "0xE8bc3B607CfE68F47000E3d200310D49041148Fc",
        "0xdac17f958d2ee523a2206206994597c13d831ec7",
    )
    
    err = paycrest.Initialize()
    if err != nil {
        log.Fatal(err)
    }
    
    recipient := map[string]interface{}{
        "institution":       "GTBINGLA",
        "accountIdentifier": "123456789",
    }
    
    err = paycrest.CreateOrder("100", recipient, "0x123...")
    if err != nil {
        log.Fatal(err)
    }
}

# Smart contract interactions are typically done in your application code
# rather than with cURL. Use one of the programming language examples above.

Supported Networks

Ethereum: USDT, USDC, cNGN
Base: USDT, USDC, cNGN (primary recommended network)
Arbitrum One: USDT, USDC
Polygon: USDT, USDC, cNGN
BNB Smart Chain: USDT, USDC, cNGN
Lisk: USDT, USDC
Celo: USDT, USDC
Starknet: USDT, USDC

Tron and Solana are supported through the Sender API (v2) only, not through direct contract calls. See Gateway Contract Addresses for deployment addresses per network.

Paycrest supports very low minimum orders ($0.50) and uses cost-effective EVM L2s. Start with small amounts to test your integration before scaling up.

Failed transactions still consume gas. Validate all parameters before submitting transactions.

Choose this method for full onchain control and direct smart contract interaction.

Getting Started

Core Concepts

Implementation Guides

Resources

Smart Contract Interaction

Overview

Prerequisites

Connect Wallet

Initialize Contracts

Create an Order

Exchange Rate and Account Verification

Data Encryption

Routing fields

Onchain Attribution (ERC-8021)

Who appends the suffix

Your sender code

Suffix layout

Encoding the suffix

Appending to createOrder

Where the suffix must live

Codes and the Base Builder Code

Relationship to `metadata.apiKey`

Network support

Token Approval

Get Order Information

Event Listening

Error Handling

Complete Example

Supported Networks

​Overview

​Prerequisites

​Connect Wallet

​Initialize Contracts

​Create an Order

​Exchange Rate and Account Verification

​Data Encryption

​Routing fields

​Onchain Attribution (ERC-8021)

​Who appends the suffix

​Your sender code

​Suffix layout

​Encoding the suffix

​Appending to createOrder

​Where the suffix must live

​Codes and the Base Builder Code

​Relationship to metadata.apiKey

​Network support

​Token Approval

​Get Order Information

​Event Listening

​Error Handling

​Complete Example

​Supported Networks

Overview

Prerequisites

Connect Wallet

Initialize Contracts

Create an Order

Exchange Rate and Account Verification

Data Encryption

Routing fields

Onchain Attribution (ERC-8021)

Who appends the suffix

Your sender code

Suffix layout

Encoding the suffix

Appending to createOrder

Where the suffix must live

Codes and the Base Builder Code

Relationship to `metadata.apiKey`

Network support

Token Approval

Get Order Information

Event Listening

Error Handling

Complete Example

Supported Networks