转化回调 API

import hashlib
import hmac
import json
import time
import urllib.request

BASE_URL = "https://openapi.pre.voypace.com"  # production: https://openapi.voypace.com
API_KEY = "ck_test_..."  # your callback API key
SECRET = "cs_..."        # your signing secret


def sign(secret: str, timestamp: str, raw_body: bytes) -> str:
    message = timestamp.encode("utf-8") + b"." + raw_body
    return hmac.new(secret.encode("utf-8"), message, hashlib.sha256).hexdigest()


def send(event: dict) -> dict:
    # Serialize once, sign these exact bytes, and send the same bytes.
    raw_body = json.dumps(event, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
    timestamp = str(int(time.time()))
    request = urllib.request.Request(
        BASE_URL + "/v1/callbacks",
        data=raw_body,
        method="POST",
        headers={
            "Content-Type": "application/json",
            "X-Api-Key": API_KEY,
            "X-Timestamp": timestamp,
            "X-Signature": sign(SECRET, timestamp, raw_body),
        },
    )
    with urllib.request.urlopen(request, timeout=5) as response:  # raises HTTPError on 4xx/5xx
        return json.load(response)

const crypto = require("node:crypto");

const BASE_URL = "https://openapi.pre.voypace.com"; // production: https://openapi.voypace.com
const API_KEY = "ck_test_..."; // your callback API key
const SECRET = "cs_...";       // your signing secret

function sign(secret, timestamp, rawBody) {
  return crypto.createHmac("sha256", secret).update(`${timestamp}.${rawBody}`, "utf8").digest("hex");
}

async function send(event) {
  // Serialize once, sign these exact bytes, and send the same string.
  const rawBody = JSON.stringify(event);
  const timestamp = String(Math.floor(Date.now() / 1000));
  const response = await fetch(`${BASE_URL}/v1/callbacks`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-Api-Key": API_KEY,
      "X-Timestamp": timestamp,
      "X-Signature": sign(SECRET, timestamp, rawBody),
    },
    body: rawBody,
    signal: AbortSignal.timeout(5000),
  });
  return { status: response.status, body: await response.json() };
}

module.exports = { sign, send };

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.HexFormat;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

public class Callback {
    static final String BASE_URL = "https://openapi.pre.voypace.com"; // production: https://openapi.voypace.com
    static final String API_KEY = "ck_test_..."; // your callback API key
    static final String SECRET = "cs_...";       // your signing secret

    static String sign(String secret, String timestamp, byte[] rawBody) throws Exception {
        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(new SecretKeySpec(secret.getBytes(StandardCharsets.UTF_8), "HmacSHA256"));
        mac.update((timestamp + ".").getBytes(StandardCharsets.UTF_8));
        return HexFormat.of().formatHex(mac.doFinal(rawBody));
    }

    static HttpResponse<String> send(String jsonBody) throws Exception {
        byte[] rawBody = jsonBody.getBytes(StandardCharsets.UTF_8);
        String timestamp = String.valueOf(System.currentTimeMillis() / 1000);
        HttpRequest request = HttpRequest.newBuilder(URI.create(BASE_URL + "/v1/callbacks"))
                .timeout(Duration.ofSeconds(5))
                .header("Content-Type", "application/json")
                .header("X-Api-Key", API_KEY)
                .header("X-Timestamp", timestamp)
                .header("X-Signature", sign(SECRET, timestamp, rawBody))
                .POST(HttpRequest.BodyPublishers.ofByteArray(rawBody))
                .build();
        return HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
    }
}

package voypace

import (
	"bytes"
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"net/http"
	"strconv"
	"time"
)

const (
	BaseURL = "https://openapi.pre.voypace.com" // production: https://openapi.voypace.com
	APIKey  = "ck_test_..."                     // your callback API key
	Secret  = "cs_..."                          // your signing secret
)

func Sign(secret, timestamp string, rawBody []byte) string {
	mac := hmac.New(sha256.New, []byte(secret))
	mac.Write([]byte(timestamp + "."))
	mac.Write(rawBody)
	return hex.EncodeToString(mac.Sum(nil))
}

func Send(rawBody []byte) (*http.Response, error) {
	timestamp := strconv.FormatInt(time.Now().Unix(), 10)
	req, err := http.NewRequest(http.MethodPost, BaseURL+"/v1/callbacks", bytes.NewReader(rawBody))
	if err != nil {
		return nil, err
	}
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("X-Api-Key", APIKey)
	req.Header.Set("X-Timestamp", timestamp)
	req.Header.Set("X-Signature", Sign(Secret, timestamp, rawBody))
	client := &http.Client{Timeout: 5 * time.Second}
	return client.Do(req)
}

<?php
const BASE_URL = 'https://openapi.pre.voypace.com'; // production: https://openapi.voypace.com
const API_KEY = 'ck_test_...'; // your callback API key
const SECRET = 'cs_...';       // your signing secret

function sign(string $secret, string $timestamp, string $rawBody): string {
    return hash_hmac('sha256', $timestamp . '.' . $rawBody, $secret);
}

function send(array $event): array {
    // Encode once, sign these exact bytes, and send the same string.
    $rawBody = json_encode($event, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE);
    $timestamp = (string) time();
    $ch = curl_init(BASE_URL . '/v1/callbacks');
    curl_setopt_array($ch, [
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => $rawBody,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 5,
        CURLOPT_HTTPHEADER => [
            'Content-Type: application/json',
            'X-Api-Key: ' . API_KEY,
            'X-Timestamp: ' . $timestamp,
            'X-Signature: ' . sign(SECRET, $timestamp, $rawBody),
        ],
    ]);
    $body = curl_exec($ch);
    $status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    return ['status' => $status, 'body' => json_decode($body, true)];
}