Live delivery rates with a callback

import crypto from "node:crypto";
import express from "express";

const MINUTE = 60 * 1000;
const DAY = 24 * 60 * MINUTE;

// During a secret rotation, list both secrets.
const secrets = process.env.FLINT_DELIVERY_RATE_SECRETS.split(",");
// A retry reuses the evaluation ID. Use a shared store with expiry in production.
const responses = new Map();
// Replace these IDs with the delivery_method_id values from your create responses.
const services = new Map([
  ["dmet_01K4STANDARD", "standard"],
  ["dmet_01K4EXPRESS", "express"],
]);

const app = express();

app.post(
  "/flint/delivery-rates",
  express.raw({ type: "*/*", limit: "256kb" }),
  async (req, res) => {
    try {
      verifySignature(req.body, req.headers, secrets);
    } catch {
      return res.status(401).end();
    }

    if (req.headers["x-flint-event-type"] === "delivery_rate_callback.connection_check") {
      return res.json({});
    }

    const evaluation = JSON.parse(req.body);
    const id = evaluation.delivery_rate_evaluation_id;
    if (!responses.has(id)) {
      responses.set(id, priceEvaluation(evaluation));
    }
    res.json(await responses.get(id));
  },
);

function verifySignature(rawBody, headers, secrets, toleranceSeconds = 300) {
  const id = headers["webhook-id"];
  const timestamp = Number(headers["webhook-timestamp"]);
  const signatures = String(headers["webhook-signature"] ?? "")
    .split(" ")
    .filter((part) => part.startsWith("v1,"))
    .map((part) => Buffer.from(part.slice(3)));

  if (!id || !Number.isInteger(timestamp) || signatures.length === 0) {
    throw new Error("Missing signature headers");
  }
  if (Math.abs(Date.now() / 1000 - timestamp) > toleranceSeconds) {
    throw new Error("Timestamp outside tolerance");
  }

  const signedContent = Buffer.concat([Buffer.from(`${id}.${timestamp}.`), rawBody]);
  const valid = secrets.some((secret) => {
    const key = Buffer.from(secret.replace(/^whsec_/, ""), "base64");
    const expected = Buffer.from(
      crypto.createHmac("sha256", key).update(signedContent).digest("base64"),
    );
    return signatures.some(
      (signature) =>
        signature.length === expected.length && crypto.timingSafeEqual(signature, expected),
    );
  });
  if (!valid) {
    throw new Error("Signature mismatch");
  }
}

async function priceEvaluation(evaluation) {
  const method_results = await Promise.all(
    evaluation.candidates.map(async (candidate) => ({
      delivery_method_revision_id: candidate.delivery_method_revision_id,
      outcome: await priceCandidate(evaluation, candidate),
    })),
  );
  return {
    delivery_rate_evaluation_id: evaluation.delivery_rate_evaluation_id,
    method_results,
  };
}

async function priceCandidate(evaluation, candidate) {
  const service = evaluation.test ? "standard" : services.get(candidate.delivery_method_id);
  if (!service) {
    return { type: "unavailable", unavailable_reason: "pricing_unavailable" };
  }
  let rate;
  try {
    rate = await quoteCarrier({
      service,
      currency: evaluation.currency,
      destination: evaluation.destination,
      weightGrams: candidate.pricing.total_weight_grams,
    });
  } catch {
    return { type: "cannot_calculate", failure_category: "dependency_failure", retryable: true };
  }
  if (!rate) {
    return { type: "unavailable", unavailable_reason: "destination_not_served" };
  }

  // Compute every time from evaluated_at, not from your server's clock.
  const evaluatedAt = Date.parse(evaluation.evaluated_at);
  const at = (offset) => new Date(evaluatedAt + offset).toISOString();
  return {
    type: "available",
    amount_money: { amount: rate.amount, currency: evaluation.currency },
    expires_at: at(10 * MINUTE),
    selection_guarantee_expires_at: at(30 * MINUTE),
    window_start_at: at(rate.minDays * DAY),
    window_end_at: at((rate.maxDays + 1) * DAY),
    merchant_reference: rate.reference,
  };
}

// Replace with your carrier or rate-shopping API.
async function quoteCarrier({ service, currency, destination, weightGrams }) {
  if (currency !== "USD" || destination?.country !== "US") {
    return null;
  }
  const kilograms = Math.max(1, Math.ceil(weightGrams / 1000));
  return service === "express"
    ? { amount: 1800 + 400 * kilograms, minDays: 1, maxDays: 2, reference: `express-${kilograms}kg` }
    : { amount: 600 + 150 * kilograms, minDays: 3, maxDays: 5, reference: `standard-${kilograms}kg` };
}

app.listen(3000);

import base64
import hashlib
import hmac
import math
import os
import time
from datetime import datetime, timedelta

from flask import Flask, abort, jsonify, request

app = Flask(__name__)

# During a secret rotation, list both secrets.
SECRETS = os.environ["FLINT_DELIVERY_RATE_SECRETS"].split(",")
# A retry reuses the evaluation ID. Use a shared store with expiry in production.
responses = {}
# Replace these IDs with the delivery_method_id values from your create responses.
SERVICES = {"dmet_01K4STANDARD": "standard", "dmet_01K4EXPRESS": "express"}


@app.post("/flint/delivery-rates")
def delivery_rates():
    raw_body = request.get_data()
    try:
        verify_signature(raw_body, request.headers, SECRETS)
    except ValueError:
        abort(401)

    if request.headers.get("X-Flint-Event-Type") == "delivery_rate_callback.connection_check":
        return jsonify({})

    evaluation = request.get_json(force=True)
    evaluation_id = evaluation["delivery_rate_evaluation_id"]
    if evaluation_id not in responses:
        responses[evaluation_id] = price_evaluation(evaluation)
    return jsonify(responses[evaluation_id])


def verify_signature(raw_body: bytes, headers, secrets: list, tolerance_seconds: int = 300) -> None:
    message_id = headers.get("webhook-id", "")
    timestamp = headers.get("webhook-timestamp", "")
    signatures = [
        part[3:] for part in headers.get("webhook-signature", "").split(" ") if part.startswith("v1,")
    ]
    if not message_id or not timestamp.isdigit() or not signatures:
        raise ValueError("Missing signature headers")
    if abs(time.time() - int(timestamp)) > tolerance_seconds:
        raise ValueError("Timestamp outside tolerance")

    signed_content = f"{message_id}.{timestamp}.".encode() + raw_body
    for secret in secrets:
        key = base64.b64decode(secret.removeprefix("whsec_"))
        expected = base64.b64encode(hmac.new(key, signed_content, hashlib.sha256).digest()).decode()
        if any(hmac.compare_digest(expected, signature) for signature in signatures):
            return
    raise ValueError("Signature mismatch")


def price_evaluation(evaluation: dict) -> dict:
    return {
        "delivery_rate_evaluation_id": evaluation["delivery_rate_evaluation_id"],
        "method_results": [
            {
                "delivery_method_revision_id": candidate["delivery_method_revision_id"],
                "outcome": price_candidate(evaluation, candidate),
            }
            for candidate in evaluation["candidates"]
        ],
    }


def price_candidate(evaluation: dict, candidate: dict) -> dict:
    service = "standard" if evaluation.get("test") else SERVICES.get(candidate["delivery_method_id"])
    if service is None:
        return {"type": "unavailable", "unavailable_reason": "pricing_unavailable"}
    try:
        rate = quote_carrier(
            service,
            evaluation["currency"],
            evaluation.get("destination"),
            candidate["pricing"]["total_weight_grams"],
        )
    except Exception:
        return {"type": "cannot_calculate", "failure_category": "dependency_failure", "retryable": True}
    if rate is None:
        return {"type": "unavailable", "unavailable_reason": "destination_not_served"}

    # Compute every time from evaluated_at, not from your server's clock.
    evaluated_at = datetime.fromisoformat(evaluation["evaluated_at"].replace("Z", "+00:00"))

    def at(offset: timedelta) -> str:
        return (evaluated_at + offset).isoformat().replace("+00:00", "Z")

    return {
        "type": "available",
        "amount_money": {"amount": rate["amount"], "currency": evaluation["currency"]},
        "expires_at": at(timedelta(minutes=10)),
        "selection_guarantee_expires_at": at(timedelta(minutes=30)),
        "window_start_at": at(timedelta(days=rate["min_days"])),
        "window_end_at": at(timedelta(days=rate["max_days"] + 1)),
        "merchant_reference": rate["reference"],
    }


# Replace with your carrier or rate-shopping API.
def quote_carrier(service, currency, destination, weight_grams):
    if currency != "USD" or (destination or {}).get("country") != "US":
        return None
    kilograms = max(1, math.ceil(weight_grams / 1000))
    if service == "express":
        return {"amount": 1800 + 400 * kilograms, "min_days": 1, "max_days": 2, "reference": f"express-{kilograms}kg"}
    return {"amount": 600 + 150 * kilograms, "min_days": 3, "max_days": 5, "reference": f"standard-{kilograms}kg"}


if __name__ == "__main__":
    app.run(port=3000)

package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/base64"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"math"
	"net/http"
	"os"
	"strconv"
	"strings"
	"sync"
	"time"
)

type Money struct {
	Amount   int64  `json:"amount"`
	Currency string `json:"currency"`
}

type Evaluation struct {
	Test         bool              `json:"test"`
	EvaluationID string            `json:"delivery_rate_evaluation_id"`
	Currency     string            `json:"currency"`
	Destination  map[string]string `json:"destination"`
	EvaluatedAt  time.Time         `json:"evaluated_at"`
	Candidates   []struct {
		MethodID         string `json:"delivery_method_id"`
		MethodRevisionID string `json:"delivery_method_revision_id"`
		Pricing          struct {
			TotalWeightGrams int64 `json:"total_weight_grams"`
		} `json:"pricing"`
	} `json:"candidates"`
}

type Outcome struct {
	Type                        string `json:"type"`
	AmountMoney                 *Money `json:"amount_money,omitempty"`
	ExpiresAt                   string `json:"expires_at,omitempty"`
	SelectionGuaranteeExpiresAt string `json:"selection_guarantee_expires_at,omitempty"`
	WindowStartAt               string `json:"window_start_at,omitempty"`
	WindowEndAt                 string `json:"window_end_at,omitempty"`
	MerchantReference           string `json:"merchant_reference,omitempty"`
	UnavailableReason           string `json:"unavailable_reason,omitempty"`
	FailureCategory             string `json:"failure_category,omitempty"`
	Retryable                   bool   `json:"retryable,omitempty"`
}

type MethodResult struct {
	MethodRevisionID string  `json:"delivery_method_revision_id"`
	Outcome          Outcome `json:"outcome"`
}

type EvaluationResponse struct {
	EvaluationID  string         `json:"delivery_rate_evaluation_id"`
	MethodResults []MethodResult `json:"method_results"`
}

type cachedResponse struct {
	once sync.Once
	body []byte
}

// During a secret rotation, list both secrets.
var secrets = strings.Split(os.Getenv("FLINT_DELIVERY_RATE_SECRETS"), ",")

// A retry reuses the evaluation ID. Use a shared store with expiry in production.
var responses sync.Map

// Replace these IDs with the delivery_method_id values from your create responses.
var services = map[string]string{
	"dmet_01K4STANDARD": "standard",
	"dmet_01K4EXPRESS":  "express",
}

func main() {
	http.HandleFunc("POST /flint/delivery-rates", func(w http.ResponseWriter, r *http.Request) {
		rawBody, err := io.ReadAll(http.MaxBytesReader(w, r.Body, 256<<10))
		if err != nil {
			http.Error(w, "body too large", http.StatusRequestEntityTooLarge)
			return
		}
		if err := verifySignature(rawBody, r.Header, secrets, 5*time.Minute); err != nil {
			w.WriteHeader(http.StatusUnauthorized)
			return
		}

		w.Header().Set("Content-Type", "application/json")
		if r.Header.Get("X-Flint-Event-Type") == "delivery_rate_callback.connection_check" {
			w.Write([]byte("{}"))
			return
		}

		var evaluation Evaluation
		if err := json.Unmarshal(rawBody, &evaluation); err != nil {
			http.Error(w, "invalid JSON", http.StatusBadRequest)
			return
		}
		entry, _ := responses.LoadOrStore(evaluation.EvaluationID, &cachedResponse{})
		cached := entry.(*cachedResponse)
		cached.once.Do(func() {
			cached.body, _ = json.Marshal(priceEvaluation(evaluation))
		})
		w.Write(cached.body)
	})
	http.ListenAndServe(":3000", nil)
}

func verifySignature(rawBody []byte, headers http.Header, secrets []string, tolerance time.Duration) error {
	id := headers.Get("webhook-id")
	timestamp, err := strconv.ParseInt(headers.Get("webhook-timestamp"), 10, 64)
	if id == "" || err != nil {
		return errors.New("missing signature headers")
	}
	if math.Abs(time.Since(time.Unix(timestamp, 0)).Seconds()) > tolerance.Seconds() {
		return errors.New("timestamp outside tolerance")
	}

	signedContent := append([]byte(fmt.Sprintf("%s.%d.", id, timestamp)), rawBody...)
	for _, secret := range secrets {
		key, err := base64.StdEncoding.DecodeString(strings.TrimPrefix(secret, "whsec_"))
		if err != nil {
			continue
		}
		mac := hmac.New(sha256.New, key)
		mac.Write(signedContent)
		expected := base64.StdEncoding.EncodeToString(mac.Sum(nil))
		for _, part := range strings.Split(headers.Get("webhook-signature"), " ") {
			if signature, ok := strings.CutPrefix(part, "v1,"); ok &&
				hmac.Equal([]byte(signature), []byte(expected)) {
				return nil
			}
		}
	}
	return errors.New("signature mismatch")
}

func priceEvaluation(evaluation Evaluation) EvaluationResponse {
	response := EvaluationResponse{EvaluationID: evaluation.EvaluationID}
	for _, candidate := range evaluation.Candidates {
		service := services[candidate.MethodID]
		if evaluation.Test {
			service = "standard"
		}
		outcome := Outcome{Type: "unavailable", UnavailableReason: "pricing_unavailable"}
		if service != "" {
			outcome = priceCandidate(service, evaluation, candidate.Pricing.TotalWeightGrams)
		}
		response.MethodResults = append(response.MethodResults, MethodResult{
			MethodRevisionID: candidate.MethodRevisionID,
			Outcome:          outcome,
		})
	}
	return response
}

func priceCandidate(service string, evaluation Evaluation, weightGrams int64) Outcome {
	rate, err := quoteCarrier(service, evaluation.Currency, evaluation.Destination, weightGrams)
	if err != nil {
		return Outcome{Type: "cannot_calculate", FailureCategory: "dependency_failure", Retryable: true}
	}
	if rate == nil {
		return Outcome{Type: "unavailable", UnavailableReason: "destination_not_served"}
	}

	// Compute every time from evaluated_at, not from your server's clock.
	at := func(offset time.Duration) string {
		return evaluation.EvaluatedAt.Add(offset).UTC().Format(time.RFC3339Nano)
	}
	day := 24 * time.Hour
	return Outcome{
		Type:                        "available",
		AmountMoney:                 &Money{Amount: rate.Amount, Currency: evaluation.Currency},
		ExpiresAt:                   at(10 * time.Minute),
		SelectionGuaranteeExpiresAt: at(30 * time.Minute),
		WindowStartAt:               at(time.Duration(rate.MinDays) * day),
		WindowEndAt:                 at(time.Duration(rate.MaxDays+1) * day),
		MerchantReference:           rate.Reference,
	}
}

type carrierRate struct {
	Amount           int64
	MinDays, MaxDays int
	Reference        string
}

// Replace with your carrier or rate-shopping API.
func quoteCarrier(service, currency string, destination map[string]string, weightGrams int64) (*carrierRate, error) {
	if currency != "USD" || destination["country"] != "US" {
		return nil, nil
	}
	kilograms := max(1, (weightGrams+999)/1000)
	if service == "express" {
		return &carrierRate{1800 + 400*kilograms, 1, 2, fmt.Sprintf("express-%dkg", kilograms)}, nil
	}
	return &carrierRate{600 + 150*kilograms, 3, 5, fmt.Sprintf("standard-%dkg", kilograms)}, nil
}