@peable.to/shared-types 0.2.0

package/dist/cjs/checkoutSession.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/event.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MERCHANT_ENVIRONMENTS = exports.verifyWebhook = exports.signWebhook = exports.PAYMENT_INTENT_STATUSES = exports.isValidStatusTransition = exports.isBaseUnitString = exports.UNITS_PER_COIN = void 0;
+// @peable.to/shared-types — public API for the Peable Gateway contract.
+var money_1 = require("./money");
+Object.defineProperty(exports, "UNITS_PER_COIN", { enumerable: true, get: function () { return money_1.UNITS_PER_COIN; } });
+Object.defineProperty(exports, "isBaseUnitString", { enumerable: true, get: function () { return money_1.isBaseUnitString; } });
+var paymentIntent_1 = require("./paymentIntent");
+Object.defineProperty(exports, "isValidStatusTransition", { enumerable: true, get: function () { return paymentIntent_1.isValidStatusTransition; } });
+Object.defineProperty(exports, "PAYMENT_INTENT_STATUSES", { enumerable: true, get: function () { return paymentIntent_1.PAYMENT_INTENT_STATUSES; } });
+var webhookSigner_1 = require("./webhookSigner");
+Object.defineProperty(exports, "signWebhook", { enumerable: true, get: function () { return webhookSigner_1.signWebhook; } });
+Object.defineProperty(exports, "verifyWebhook", { enumerable: true, get: function () { return webhookSigner_1.verifyWebhook; } });
+var merchant_1 = require("./merchant");
+Object.defineProperty(exports, "MERCHANT_ENVIRONMENTS", { enumerable: true, get: function () { return merchant_1.MERCHANT_ENVIRONMENTS; } });

package/dist/cjs/merchant.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MERCHANT_ENVIRONMENTS = void 0;
+exports.MERCHANT_ENVIRONMENTS = ['development', 'staging', 'production'];

package/dist/cjs/merchantDisplay.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/money.js

@@ -0,0 +1,21 @@
+"use strict";
+// Amount helpers over FairCoin base units (m⊜). One coin is UNITS_PER_COIN
+// base units. Amounts move through the system as bigint conceptually; the
+// PaymentIntent DTO stores them as a base-unit integer string so no float ever
+// touches a monetary value.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNITS_PER_COIN = void 0;
+exports.isBaseUnitString = isBaseUnitString;
+// Frozen FairCoin consensus constant (smallest units per FAIR). Mirrors
+// @fairco.in/core's branding.ts; inlined here (rather than imported) to keep
+// @peable.to/shared-types zero-runtime-dep for a clean CJS+ESM publish — must
+// stay a bigint, never converted to number.
+exports.UNITS_PER_COIN = 100000000n;
+/**
+ * True only for a canonical non-negative integer string in base units:
+ * one or more decimal digits, no sign, no decimal point, no leading zeros
+ * (except the literal "0"). Floats and negatives are rejected.
+ */
+function isBaseUnitString(s) {
+    return /^(0|[1-9][0-9]*)$/.test(s);
+}

package/dist/cjs/network.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/paymentIntent.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PAYMENT_INTENT_STATUSES = void 0;
+exports.isValidStatusTransition = isValidStatusTransition;
+/**
+ * Legal forward transitions of the PaymentIntent lifecycle. Terminal states
+ * (settled/expired/failed/rejected) allow no further transition here — the one
+ * documented exception, a reorg dropping `settled` back to `confirming`, is
+ * modelled by the backend state machine, not this happy-path table.
+ */
+const ALLOWED = {
+    // `created` supports two paths: the rich wallet flow (→ awaiting_approval →
+    // approved → broadcast) AND the minimal path where the payer pays out-of-band
+    // and reports the txid directly (→ broadcast), or the merchant cancels an
+    // unpaid intent (→ rejected). Both are legal forward transitions.
+    created: ['awaiting_approval', 'broadcast', 'rejected', 'expired'],
+    awaiting_approval: ['approved', 'rejected', 'expired'],
+    approved: ['broadcast', 'failed'],
+    broadcast: ['confirming', 'failed'],
+    confirming: ['settled', 'failed'],
+    settled: [],
+    expired: [],
+    failed: [],
+    rejected: [],
+};
+function isValidStatusTransition(from, to) {
+    return ALLOWED[from].includes(to);
+}
+/** Every legal `PaymentIntentStatus`, derived from `ALLOWED`'s keys — the
+ * single source of truth consumed by the Gateway's list-route status filter. */
+exports.PAYMENT_INTENT_STATUSES = Object.keys(ALLOWED);

package/dist/cjs/paymentLink.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/social.js

@@ -0,0 +1,5 @@
+"use strict";
+// Social-receive + transaction-enrichment contracts — shared by the Peable
+// Gateway backend, the wallet frontend, and (indirectly) the enrichment
+// service's callers. Mirrors the Stripe-parity style of paymentIntent.ts.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/webhookDelivery.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/webhookSigner.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signWebhook = signWebhook;
+exports.verifyWebhook = verifyWebhook;
+const node_crypto_1 = require("node:crypto");
+/**
+ * Compute the hex HMAC-SHA256 of the signed payload `${timestamp}.${rawBody}`.
+ * The signed payload binds the timestamp to the body so a captured signature
+ * cannot be replayed against a different body or a shifted timestamp.
+ */
+function computeSignature(secret, rawBody, timestamp) {
+    return (0, node_crypto_1.createHmac)('sha256', secret).update(`${timestamp}.${rawBody}`).digest('hex');
+}
+/**
+ * Produce a Stripe-style signature header for an outbound webhook:
+ * `t=${timestamp},v1=${hexHmacSha256}`.
+ */
+function signWebhook(secret, rawBody, timestamp) {
+    return `t=${timestamp},v1=${computeSignature(secret, rawBody, timestamp)}`;
+}
+function parseHeader(header) {
+    let timestamp = null;
+    let signature = null;
+    for (const part of header.split(',')) {
+        const separator = part.indexOf('=');
+        if (separator === -1)
+            continue;
+        const key = part.slice(0, separator);
+        const value = part.slice(separator + 1);
+        if (key === 't') {
+            const parsed = Number(value);
+            if (Number.isInteger(parsed))
+                timestamp = parsed;
+        }
+        else if (key === 'v1') {
+            signature = value;
+        }
+    }
+    if (timestamp === null || signature === null)
+        return null;
+    return { timestamp, signature };
+}
+/**
+ * Constant-time hex-string comparison. Returns false for unequal-length inputs
+ * (timingSafeEqual throws on mismatched buffer lengths) instead of throwing.
+ */
+function constantTimeEqualHex(a, b) {
+    const bufferA = Buffer.from(a, 'hex');
+    const bufferB = Buffer.from(b, 'hex');
+    if (bufferA.length === 0 || bufferA.length !== bufferB.length)
+        return false;
+    return (0, node_crypto_1.timingSafeEqual)(bufferA, bufferB);
+}
+/**
+ * Verify a webhook signature header against the raw body.
+ * - Parses `t` and `v1` from the header.
+ * - Rejects if the timestamp drifts more than `toleranceSec` from `nowSec`.
+ * - Recomputes the expected signature and compares it in constant time.
+ */
+function verifyWebhook(secret, rawBody, header, toleranceSec, nowSec) {
+    const parsed = parseHeader(header);
+    if (parsed === null)
+        return false;
+    if (Math.abs(nowSec - parsed.timestamp) > toleranceSec)
+        return false;
+    const expected = computeSignature(secret, rawBody, parsed.timestamp);
+    return constantTimeEqualHex(expected, parsed.signature);
+}

package/dist/esm/checkoutSession.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/event.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/index.js

@@ -0,0 +1,5 @@
+// @peable.to/shared-types — public API for the Peable Gateway contract.
+export { UNITS_PER_COIN, isBaseUnitString } from './money.js';
+export { isValidStatusTransition, PAYMENT_INTENT_STATUSES, } from './paymentIntent.js';
+export { signWebhook, verifyWebhook } from './webhookSigner.js';
+export { MERCHANT_ENVIRONMENTS, } from './merchant.js';

package/dist/esm/merchant.js

@@ -0,0 +1 @@
+export const MERCHANT_ENVIRONMENTS = ['development', 'staging', 'production'];

package/dist/esm/merchantDisplay.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/money.js

@@ -0,0 +1,17 @@
+// Amount helpers over FairCoin base units (m⊜). One coin is UNITS_PER_COIN
+// base units. Amounts move through the system as bigint conceptually; the
+// PaymentIntent DTO stores them as a base-unit integer string so no float ever
+// touches a monetary value.
+// Frozen FairCoin consensus constant (smallest units per FAIR). Mirrors
+// @fairco.in/core's branding.ts; inlined here (rather than imported) to keep
+// @peable.to/shared-types zero-runtime-dep for a clean CJS+ESM publish — must
+// stay a bigint, never converted to number.
+export const UNITS_PER_COIN = 100000000n;
+/**
+ * True only for a canonical non-negative integer string in base units:
+ * one or more decimal digits, no sign, no decimal point, no leading zeros
+ * (except the literal "0"). Floats and negatives are rejected.
+ */
+export function isBaseUnitString(s) {
+    return /^(0|[1-9][0-9]*)$/.test(s);
+}

package/dist/esm/network.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/paymentIntent.js

@@ -0,0 +1,27 @@
+/**
+ * Legal forward transitions of the PaymentIntent lifecycle. Terminal states
+ * (settled/expired/failed/rejected) allow no further transition here — the one
+ * documented exception, a reorg dropping `settled` back to `confirming`, is
+ * modelled by the backend state machine, not this happy-path table.
+ */
+const ALLOWED = {
+    // `created` supports two paths: the rich wallet flow (→ awaiting_approval →
+    // approved → broadcast) AND the minimal path where the payer pays out-of-band
+    // and reports the txid directly (→ broadcast), or the merchant cancels an
+    // unpaid intent (→ rejected). Both are legal forward transitions.
+    created: ['awaiting_approval', 'broadcast', 'rejected', 'expired'],
+    awaiting_approval: ['approved', 'rejected', 'expired'],
+    approved: ['broadcast', 'failed'],
+    broadcast: ['confirming', 'failed'],
+    confirming: ['settled', 'failed'],
+    settled: [],
+    expired: [],
+    failed: [],
+    rejected: [],
+};
+export function isValidStatusTransition(from, to) {
+    return ALLOWED[from].includes(to);
+}
+/** Every legal `PaymentIntentStatus`, derived from `ALLOWED`'s keys — the
+ * single source of truth consumed by the Gateway's list-route status filter. */
+export const PAYMENT_INTENT_STATUSES = Object.keys(ALLOWED);

package/dist/esm/paymentLink.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/social.js

@@ -0,0 +1,4 @@
+// Social-receive + transaction-enrichment contracts — shared by the Peable
+// Gateway backend, the wallet frontend, and (indirectly) the enrichment
+// service's callers. Mirrors the Stripe-parity style of paymentIntent.ts.
+export {};

package/dist/esm/webhookDelivery.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/webhookSigner.js

@@ -0,0 +1,64 @@
+import { createHmac, timingSafeEqual } from 'node:crypto';
+/**
+ * Compute the hex HMAC-SHA256 of the signed payload `${timestamp}.${rawBody}`.
+ * The signed payload binds the timestamp to the body so a captured signature
+ * cannot be replayed against a different body or a shifted timestamp.
+ */
+function computeSignature(secret, rawBody, timestamp) {
+    return createHmac('sha256', secret).update(`${timestamp}.${rawBody}`).digest('hex');
+}
+/**
+ * Produce a Stripe-style signature header for an outbound webhook:
+ * `t=${timestamp},v1=${hexHmacSha256}`.
+ */
+export function signWebhook(secret, rawBody, timestamp) {
+    return `t=${timestamp},v1=${computeSignature(secret, rawBody, timestamp)}`;
+}
+function parseHeader(header) {
+    let timestamp = null;
+    let signature = null;
+    for (const part of header.split(',')) {
+        const separator = part.indexOf('=');
+        if (separator === -1)
+            continue;
+        const key = part.slice(0, separator);
+        const value = part.slice(separator + 1);
+        if (key === 't') {
+            const parsed = Number(value);
+            if (Number.isInteger(parsed))
+                timestamp = parsed;
+        }
+        else if (key === 'v1') {
+            signature = value;
+        }
+    }
+    if (timestamp === null || signature === null)
+        return null;
+    return { timestamp, signature };
+}
+/**
+ * Constant-time hex-string comparison. Returns false for unequal-length inputs
+ * (timingSafeEqual throws on mismatched buffer lengths) instead of throwing.
+ */
+function constantTimeEqualHex(a, b) {
+    const bufferA = Buffer.from(a, 'hex');
+    const bufferB = Buffer.from(b, 'hex');
+    if (bufferA.length === 0 || bufferA.length !== bufferB.length)
+        return false;
+    return timingSafeEqual(bufferA, bufferB);
+}
+/**
+ * Verify a webhook signature header against the raw body.
+ * - Parses `t` and `v1` from the header.
+ * - Rejects if the timestamp drifts more than `toleranceSec` from `nowSec`.
+ * - Recomputes the expected signature and compares it in constant time.
+ */
+export function verifyWebhook(secret, rawBody, header, toleranceSec, nowSec) {
+    const parsed = parseHeader(header);
+    if (parsed === null)
+        return false;
+    if (Math.abs(nowSec - parsed.timestamp) > toleranceSec)
+        return false;
+    const expected = computeSignature(secret, rawBody, parsed.timestamp);
+    return constantTimeEqualHex(expected, parsed.signature);
+}

package/dist/types/checkoutSession.d.ts

@@ -0,0 +1,41 @@
+import type { NetworkType } from './network';
+import type { MerchantDisplay } from './merchantDisplay';
+import type { PaymentIntent } from './paymentIntent';
+/** The merchant/SDK-facing DTO — returned on create and by merchant retrieve. */
+export interface CheckoutSession {
+    id: string;
+    object: 'checkout_session';
+    paymentIntentId: string;
+    /** The wrapped intent's `client_secret`, returned to the merchant on create. */
+    clientSecret: string;
+    amount: string;
+    network: NetworkType;
+    metadata: Record<string, string>;
+    successUrl?: string;
+    cancelUrl?: string;
+    /** Canonical `checkout.peable.to/c/<id>` URL. */
+    url: string;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * What the checkout page loads at `/c/:id`, authorized by possession of the
+ * wrapped intent's `client_secret` (never a service token). `paymentIntent`
+ * reuses `toPaymentIntentDTO`'s output unchanged — it already carries
+ * `clientSecret`, which the page needs to open the socket and to `submit_tx`.
+ */
+export interface CheckoutSessionPublic {
+    id: string;
+    object: 'checkout_session';
+    successUrl?: string;
+    cancelUrl?: string;
+    merchant: MerchantDisplay;
+    paymentIntent: PaymentIntent;
+}
+export interface CreateCheckoutSessionParams {
+    amount: string;
+    network: NetworkType;
+    metadata?: Record<string, string>;
+    successUrl?: string;
+    cancelUrl?: string;
+}

package/dist/types/event.d.ts

@@ -0,0 +1,11 @@
+import type { PaymentIntent } from './paymentIntent';
+export type WebhookEventType = 'payment_intent.confirming' | 'payment_intent.settled' | 'payment_intent.failed' | 'payment_intent.rejected' | 'payment_intent.expired';
+export interface WebhookEvent<T = PaymentIntent> {
+    id: string;
+    object: 'event';
+    type: WebhookEventType;
+    created: string;
+    data: {
+        object: T;
+    };
+}

package/dist/types/index.d.ts

@@ -0,0 +1,11 @@
+export { UNITS_PER_COIN, isBaseUnitString } from './money';
+export { type NetworkType } from './network';
+export { type PaymentIntentStatus, type PaymentIntent, type CreatePaymentIntentParams, isValidStatusTransition, PAYMENT_INTENT_STATUSES, } from './paymentIntent';
+export { type WebhookEventType, type WebhookEvent } from './event';
+export { type WebhookDelivery } from './webhookDelivery';
+export { signWebhook, verifyWebhook } from './webhookSigner';
+export { type MerchantEnvironment, type Merchant, MERCHANT_ENVIRONMENTS, } from './merchant';
+export { type MerchantDisplay } from './merchantDisplay';
+export { type PaymentLink, type PublicPaymentLink, type CreatePaymentLinkParams, } from './paymentLink';
+export { type CheckoutSession, type CheckoutSessionPublic, type CreateCheckoutSessionParams, } from './checkoutSession';
+export { type SocialNextAddressResponse, type SocialReceiveCursorResponse, type EnrichmentKind, type EnrichmentResult, type EnrichRequest, type EnrichResponse, } from './social';

package/dist/types/merchant.d.ts

@@ -0,0 +1,15 @@
+import type { NetworkType } from './network';
+export declare const MERCHANT_ENVIRONMENTS: readonly ["development", "staging", "production"];
+export type MerchantEnvironment = (typeof MERCHANT_ENVIRONMENTS)[number];
+export interface Merchant {
+    id: string;
+    object: 'merchant';
+    oxyAppId: string;
+    environment: MerchantEnvironment;
+    network: NetworkType;
+    xpub: string;
+    webhookUrl?: string;
+    requiredConfirmations: number;
+    createdAt: string;
+    updatedAt: string;
+}

package/dist/types/merchantDisplay.d.ts

@@ -0,0 +1,7 @@
+export interface MerchantDisplay {
+    /** `Merchant.displayName`, or a neutral fallback when unset. */
+    name: string;
+    /** Resolved server-side via the canonical media chokepoint; `null` when the merchant has no avatar. */
+    avatarUrl: string | null;
+    description: string | null;
+}

package/dist/types/money.d.ts

@@ -0,0 +1,7 @@
+export declare const UNITS_PER_COIN = 100000000n;
+/**
+ * True only for a canonical non-negative integer string in base units:
+ * one or more decimal digits, no sign, no decimal point, no leading zeros
+ * (except the literal "0"). Floats and negatives are rejected.
+ */
+export declare function isBaseUnitString(s: string): boolean;

package/dist/types/network.d.ts

@@ -0,0 +1 @@
+export type NetworkType = 'mainnet' | 'testnet';

package/dist/types/paymentIntent.d.ts

@@ -0,0 +1,32 @@
+import type { NetworkType } from './network';
+export type PaymentIntentStatus = 'created' | 'awaiting_approval' | 'approved' | 'broadcast' | 'confirming' | 'settled' | 'expired' | 'failed' | 'rejected';
+export declare function isValidStatusTransition(from: PaymentIntentStatus, to: PaymentIntentStatus): boolean;
+/** Every legal `PaymentIntentStatus`, derived from `ALLOWED`'s keys — the
+ * single source of truth consumed by the Gateway's list-route status filter. */
+export declare const PAYMENT_INTENT_STATUSES: readonly PaymentIntentStatus[];
+export interface PaymentIntent {
+    id: string;
+    object: 'payment_intent';
+    status: PaymentIntentStatus;
+    /** Amount in base units (m⊜) as a canonical integer string. Never a float. */
+    amount: string;
+    currency: 'FAIR';
+    network: NetworkType;
+    /** Watch-only receive address derived per-intent from the merchant xpub. */
+    address: string;
+    merchantId: string;
+    txid: string | null;
+    confirmations: number;
+    clientSecret: string;
+    metadata: Record<string, string>;
+    expiresAt: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreatePaymentIntentParams {
+    /** Amount in base units (m⊜) as a canonical integer string. */
+    amount: string;
+    network: NetworkType;
+    metadata?: Record<string, string>;
+    expiresInSeconds?: number;
+}

package/dist/types/paymentLink.d.ts

@@ -0,0 +1,33 @@
+import type { NetworkType } from './network';
+import type { MerchantDisplay } from './merchantDisplay';
+/** The merchant-facing DTO — returned by the merchant-authed CRUD routes. */
+export interface PaymentLink {
+    id: string;
+    object: 'payment_link';
+    /** Amount in base units (m⊜) as a canonical integer string. Never a float. */
+    amount: string;
+    network: NetworkType;
+    active: boolean;
+    metadata: Record<string, string>;
+    /** Optional post-payment redirect target for the checkout page. */
+    successUrl?: string;
+    /** Canonical `checkout.peable.to/l/<id>` URL. */
+    url: string;
+    createdAt: string;
+    updatedAt: string;
+}
+/** What an unauthenticated checkout-page visitor may see — no secrets, no metadata. */
+export interface PublicPaymentLink {
+    id: string;
+    object: 'payment_link';
+    amount: string;
+    network: NetworkType;
+    active: boolean;
+    merchant: MerchantDisplay;
+}
+export interface CreatePaymentLinkParams {
+    amount: string;
+    network: NetworkType;
+    metadata?: Record<string, string>;
+    successUrl?: string;
+}

package/dist/types/social.d.ts

@@ -0,0 +1,50 @@
+/** Response of `POST /v1/social/:username/next_address` (spec §4.4 step 3). */
+export interface SocialNextAddressResponse {
+    address: string;
+    index: number;
+}
+/**
+ * Response of `GET /v1/social/me/cursor` — lets the authenticated user's
+ * device resync its social-receive watch window against the backend's
+ * reservation cursor. `reserveNextSocialAddress` advances a MONOTONIC index
+ * on every `next_address` call regardless of whether the reserved address is
+ * ever paid, but a receiving device only widens its watch window when a
+ * payment lands on an index it already watches — so a burst of reservations
+ * with no payment in between (griefing, or a payer browsing/re-picking a
+ * recipient) can silently outrun the device. Calling this endpoint tells the
+ * device how far to widen: watch `0..reservedThrough+gap`.
+ */
+export interface SocialReceiveCursorResponse {
+    /**
+     * Highest social-receive index the backend has EVER reserved for the
+     * caller, for the queried network. `0` when the caller has never had an
+     * address reserved (no cursor exists yet) — mirrors
+     * `SOCIAL_RECEIVE_FIRST_FRESH_INDEX - 1`, since index 0 itself is the
+     * caller's stable default address and is never reserved through this flow.
+     */
+    reservedThrough: number;
+}
+/** Where a transaction's counterparty identity came from (spec §4.8). */
+export type EnrichmentKind = 'merchant' | 'user' | 'unknown';
+/**
+ * Display-only counterparty identity for one address/txid, resolved by
+ * `POST /v1/enrich`. Never affects custody; a failed/partial resolution
+ * degrades to `{ kind: 'unknown' }`.
+ */
+export interface EnrichmentResult {
+    kind: EnrichmentKind;
+    /** Merchant name or user's `name.displayName ?? handle`. */
+    displayName?: string;
+    /** Bare Oxy file id — render via the canonical media chokepoint, never a URL. */
+    avatarFileId?: string;
+    /** Present for `kind: 'user'` only. */
+    username?: string;
+    /** Present for `kind: 'merchant'` only. */
+    description?: string;
+}
+export interface EnrichRequest {
+    addresses: string[];
+}
+export interface EnrichResponse {
+    data: Record<string, EnrichmentResult>;
+}

package/dist/types/webhookDelivery.d.ts

@@ -0,0 +1,15 @@
+import type { WebhookEventType } from './event';
+export interface WebhookDelivery {
+    id: string;
+    object: 'webhook_delivery';
+    merchantId: string;
+    intentId: string;
+    eventId: string;
+    eventType: WebhookEventType;
+    url: string;
+    attempts: number;
+    delivered: boolean;
+    lastStatus: 'delivered' | 'failed';
+    createdAt: string;
+    updatedAt: string;
+}

package/dist/types/webhookSigner.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Produce a Stripe-style signature header for an outbound webhook:
+ * `t=${timestamp},v1=${hexHmacSha256}`.
+ */
+export declare function signWebhook(secret: string, rawBody: string, timestamp: number): string;
+/**
+ * Verify a webhook signature header against the raw body.
+ * - Parses `t` and `v1` from the header.
+ * - Rejects if the timestamp drifts more than `toleranceSec` from `nowSec`.
+ * - Recomputes the expected signature and compares it in constant time.
+ */
+export declare function verifyWebhook(secret: string, rawBody: string, header: string, toleranceSec: number, nowSec: number): boolean;

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@peable.to/shared-types",
+  "version": "0.2.0",
+  "description": "Shared TypeScript types for the Peable Gateway — the wire contract shared by the backend, SDK, and frontend.",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/types/index.d.ts",
+  "source": "src/index.ts",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "react-native": "./dist/esm/index.js",
+      "import": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      },
+      "default": "./dist/esm/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "peable",
+    "gateway",
+    "payments",
+    "types"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/OxyHQ/Peable.git",
+    "directory": "packages/shared-types"
+  },
+  "author": "Peable",
+  "license": "MIT",
+  "homepage": "https://peable.to",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "bun run build:cjs && bun run build:esm && bun run build:types",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json && node scripts/fix-esm-imports.mjs",
+    "build:types": "tsc -p tsconfig.types.json",
+    "clean": "rm -rf dist",
+    "dev": "tsc --watch",
+    "lint": "tsc --noEmit",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "prepublishOnly": "bun run clean && bun run build"
+  },
+  "devDependencies": {
+    "typescript": "~5.9.2",
+    "@types/node": "^20.0.0",
+    "@types/bun": "latest"
+  }
+}