@rozoai/intent-common 0.0.1

package/dist/rozoPay.d.ts

@@ -0,0 +1,450 @@
+import { Address, Hex } from "viem";
+import z from "zod";
+import { Token } from "./token";
+import { BigIntStr, SolanaPublicKey } from "./primitiveTypes";
+export declare enum RozoPayOrderStatusSource {
+    WAITING_PAYMENT = "waiting_payment",
+    PENDING_PROCESSING = "pending_processing",
+    START_SUBMITTED = "start_submitted",
+    PROCESSED = "processed"
+}
+export declare enum RozoPayOrderStatusDest {
+    PENDING = "pending",
+    FAST_FINISH_SUBMITTED = "fast_finish_submitted",
+    FAST_FINISHED = "fast_finished",
+    CLAIM_SUCCESSFUL = "claimed"
+}
+export declare enum RozoPayOrderMode {
+    SALE = "sale",// product or item sale
+    CHOOSE_AMOUNT = "choose_amount",// let the user specify the amount to pay
+    HYDRATED = "hydrated"
+}
+/**
+ * Status values:
+ * - `payment_unpaid` - the user has not paid yet
+ * - `payment_started` - the user has paid & payment is in progress. This status
+ *    typically lasts a few seconds.
+ * - `payment_completed` - the final call or transfer succeeded
+ * - `payment_bounced` - the final call or transfer reverted. Funds were sent
+ *    to the payment's configured refund address on the destination chain.
+ */
+export declare enum RozoPayIntentStatus {
+    UNPAID = "payment_unpaid",
+    STARTED = "payment_started",
+    COMPLETED = "payment_completed",
+    BOUNCED = "payment_bounced"
+}
+export interface RozoPayOrderItem {
+    name: string;
+    description: string;
+    image?: string;
+}
+export declare const zBridgeTokenOutOptions: z.ZodArray<z.ZodObject<{
+    token: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+    amount: z.ZodEffects<z.ZodEffects<z.ZodString, `${bigint}`, string>, bigint, string>;
+}, "strip", z.ZodTypeAny, {
+    token: `0x${string}`;
+    amount: bigint;
+}, {
+    token: string;
+    amount: string;
+}>, "many">;
+export type BridgeTokenOutOptions = z.infer<typeof zBridgeTokenOutOptions>;
+export declare const zRozoPayOrderMetadata: z.ZodObject<{
+    style: z.ZodOptional<z.ZodObject<{
+        background: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        background?: string | undefined;
+    }, {
+        background?: string | undefined;
+    }>>;
+    orgLogo: z.ZodOptional<z.ZodString>;
+    intent: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        image: z.ZodOptional<z.ZodString>;
+        price: z.ZodOptional<z.ZodString>;
+        priceDetails: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description: string;
+        image?: string | undefined;
+        price?: string | undefined;
+        priceDetails?: string | undefined;
+    }, {
+        name: string;
+        description: string;
+        image?: string | undefined;
+        price?: string | undefined;
+        priceDetails?: string | undefined;
+    }>, "many">;
+    payer: z.ZodOptional<z.ZodObject<{
+        preferredChains: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+        preferredTokens: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            chain: z.ZodNumber;
+            address: z.ZodEffects<z.ZodEffects<z.ZodString, `0x${string}`, string>, `0x${string}`, string>;
+        }, "strip", z.ZodTypeAny, {
+            chain: number;
+            address: `0x${string}`;
+        }, {
+            chain: number;
+            address: string;
+        }>, "many">>;
+        evmChains: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+        paymentOptions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        preferredChains?: number[] | undefined;
+        preferredTokens?: {
+            chain: number;
+            address: `0x${string}`;
+        }[] | undefined;
+        evmChains?: number[] | undefined;
+        paymentOptions?: string[] | undefined;
+    }, {
+        preferredChains?: number[] | undefined;
+        preferredTokens?: {
+            chain: number;
+            address: string;
+        }[] | undefined;
+        evmChains?: number[] | undefined;
+        paymentOptions?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    intent: string;
+    items: {
+        name: string;
+        description: string;
+        image?: string | undefined;
+        price?: string | undefined;
+        priceDetails?: string | undefined;
+    }[];
+    style?: {
+        background?: string | undefined;
+    } | undefined;
+    orgLogo?: string | undefined;
+    payer?: {
+        preferredChains?: number[] | undefined;
+        preferredTokens?: {
+            chain: number;
+            address: `0x${string}`;
+        }[] | undefined;
+        evmChains?: number[] | undefined;
+        paymentOptions?: string[] | undefined;
+    } | undefined;
+}, {
+    intent: string;
+    items: {
+        name: string;
+        description: string;
+        image?: string | undefined;
+        price?: string | undefined;
+        priceDetails?: string | undefined;
+    }[];
+    style?: {
+        background?: string | undefined;
+    } | undefined;
+    orgLogo?: string | undefined;
+    payer?: {
+        preferredChains?: number[] | undefined;
+        preferredTokens?: {
+            chain: number;
+            address: string;
+        }[] | undefined;
+        evmChains?: number[] | undefined;
+        paymentOptions?: string[] | undefined;
+    } | undefined;
+}>;
+export type RozoPayOrderMetadata = z.infer<typeof zRozoPayOrderMetadata>;
+/**
+ * The user-passed metadata must meet these criteria:
+ * - All keys must be strings
+ * - All values must be strings
+ * - At most 50 key-value pairs
+ * - Maximum of 40 characters per key
+ * - Maximum of 500 characters per value
+ */
+export declare const zRozoPayUserMetadata: z.ZodEffects<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>, Record<string, string> | null, Record<string, string> | null>;
+export type RozoPayUserMetadata = z.infer<typeof zRozoPayUserMetadata>;
+export type RozoPayDehydratedOrder = {
+    mode: RozoPayOrderMode.SALE | RozoPayOrderMode.CHOOSE_AMOUNT;
+    id: bigint;
+    destFinalCallTokenAmount: RozoPayTokenAmount;
+    destFinalCall: OnChainCall;
+    nonce: bigint;
+    redirectUri: string | null;
+    orgId: string | null;
+    createdAt: number | null;
+    lastUpdatedAt: number | null;
+    intentStatus: RozoPayIntentStatus;
+    metadata: RozoPayOrderMetadata;
+    externalId: string | null;
+    userMetadata: RozoPayUserMetadata | null;
+    refundAddr: Address | null;
+};
+export type RozoPayHydratedOrder = {
+    mode: RozoPayOrderMode.HYDRATED;
+    id: bigint;
+    intentAddr: Address;
+    /** Nullable because old intents don't record escrow address. */
+    escrowContractAddress: Address | null;
+    /** Nullable because old intents don't record bridger address. */
+    bridgerContractAddress: Address | null;
+    /** @deprecated included for backcompat with old versions. Remove soon. */
+    handoffAddr: Address;
+    bridgeTokenOutOptions: RozoPayTokenAmount[];
+    selectedBridgeTokenOutAddr: Address | null;
+    selectedBridgeTokenOutAmount: bigint | null;
+    destFinalCallTokenAmount: RozoPayTokenAmount;
+    destFinalCall: OnChainCall;
+    usdValue: number;
+    refundAddr: Address;
+    nonce: bigint;
+    sourceFulfillerAddr: Address | SolanaPublicKey | null;
+    sourceTokenAmount: RozoPayTokenAmount | null;
+    sourceInitiateTxHash: Hex | null;
+    sourceStartTxHash: Hex | null;
+    sourceStatus: RozoPayOrderStatusSource;
+    destStatus: RozoPayOrderStatusDest;
+    destFastFinishTxHash: Hex | null;
+    destClaimTxHash: Hex | null;
+    redirectUri: string | null;
+    orgId: string | null;
+    createdAt: number | null;
+    lastUpdatedAt: number | null;
+    intentStatus: RozoPayIntentStatus;
+    metadata: RozoPayOrderMetadata;
+    externalId: string | null;
+    userMetadata: RozoPayUserMetadata | null;
+    /** Nullable because old intents don't have expiration time. */
+    expirationTs: bigint | null;
+};
+export type RozoPayOrderWithOrg = RozoPayOrder & {
+    org: RozoPayOrgPublicInfo;
+};
+export type RozoPayHydratedOrderWithOrg = RozoPayHydratedOrder & {
+    org: RozoPayOrgPublicInfo;
+};
+export type RozoPayOrgPublicInfo = {
+    orgId: string;
+    name: string;
+    logoURI?: string;
+};
+export type RozoPayHydratedOrderWithoutIntentAddr = Omit<RozoPayHydratedOrder, "intentAddr" | "handoffAddr">;
+export type RozoPayOrder = RozoPayDehydratedOrder | RozoPayHydratedOrder;
+export declare function isHydrated(order: RozoPayOrder): order is RozoPayHydratedOrder;
+export type RozoPayOrderView = {
+    id: RozoPayOrderID;
+    status: RozoPayIntentStatus;
+    createdAt: string;
+    display: {
+        intent: string;
+        paymentValue: string;
+        currency: "USD";
+    };
+    source: {
+        payerAddress: Address | SolanaPublicKey | null;
+        txHash: Hex | string | null;
+        chainId: string;
+        amountUnits: string;
+        tokenSymbol: string;
+        tokenAddress: Address | string;
+    } | null;
+    destination: {
+        destinationAddress: Address;
+        txHash: Hex | null;
+        chainId: string;
+        amountUnits: string;
+        tokenSymbol: string;
+        tokenAddress: Address;
+        callData: Hex | null;
+    };
+    externalId: string | null;
+    metadata: RozoPayUserMetadata | null;
+};
+export declare function getOrderSourceChainId(order: RozoPayHydratedOrder): number | null;
+export declare function getOrderDestChainId(order: RozoPayOrder | RozoPayHydratedOrderWithoutIntentAddr): number;
+export declare function getRozoPayOrderView(order: RozoPayOrder): RozoPayOrderView;
+export type WalletPaymentOption = {
+    balance: RozoPayTokenAmount;
+    required: RozoPayTokenAmount;
+    minimumRequired: RozoPayTokenAmount;
+    fees: RozoPayTokenAmount;
+    disabledReason?: string;
+};
+export type ExternalPaymentOptionMetadata = {
+    id: ExternalPaymentOptions;
+    optionType: "external" | "zkp2p";
+    cta: string;
+    logoURI: string;
+    logoShape: "circle" | "squircle";
+    paymentToken: RozoPayToken;
+    disabled: boolean;
+    message?: string;
+    minimumUsd?: number;
+};
+export declare enum ExternalPaymentOptions {
+    Rozo = "Rozo",
+    Coinbase = "Coinbase",
+    RampNetwork = "RampNetwork",
+    Binance = "Binance",
+    Solana = "Solana",
+    ExternalChains = "ExternalChains",
+    Lemon = "Lemon",
+    AllPaymentApps = "AllPaymentApps",
+    Venmo = "Venmo",
+    CashApp = "CashApp",
+    MercadoPago = "MercadoPago",
+    Revolut = "Revolut",
+    Wise = "Wise"
+}
+export type ExternalPaymentOptionsString = `${ExternalPaymentOptions}`;
+export type ExternalPaymentOptionData = {
+    url: string;
+    waitingMessage: string;
+};
+export declare enum DepositAddressPaymentOptions {
+    TRON_USDT = "USDT on Tron",
+    BASE = "Base",
+    ARBITRUM = "Arbitrum",
+    OP_MAINNET = "Optimism",
+    POLYGON = "Polygon",
+    ETH_L1 = "Ethereum",
+    /** @deprecated */
+    BITCOIN = "Bitcoin",
+    /** @deprecated */
+    TON = "TON",
+    /** @deprecated */
+    MONERO = "Monero",
+    /** @deprecated */
+    DOGE = "Doge",
+    /** @deprecated */
+    LITECOIN = "Litecoin",
+    /** @deprecated */
+    ZCASH = "Zcash",
+    /** @deprecated */
+    DASH = "Dash"
+}
+export type DepositAddressPaymentOptionMetadata = {
+    id: DepositAddressPaymentOptions;
+    logoURI: string;
+    minimumUsd: number;
+};
+export type DepositAddressPaymentOptionData = {
+    address: string;
+    uri: string;
+    amount: string;
+    suffix: string;
+    expirationS: number;
+};
+export interface RozoPayToken extends Token {
+    token: Address | SolanaPublicKey;
+    /** Price to convert 1.0 of this token to a USD stablecoin. */
+    usd: number;
+    /** Price to convert $1 to this token T. If 2.00, then we receive 0.5 T. */
+    priceFromUsd: number;
+    /** Max payment accepted in this token, based on liquidity & mode. */
+    maxAcceptUsd: number;
+    /** Max payment we can send from this token, based on liquidity & mode. */
+    maxSendUsd: number;
+    /** Display decimals, separate from token decimals. Eg: 2 for USDC. */
+    displayDecimals: number;
+    /** Symbol for fiat currency, eg: "$" */
+    fiatSymbol?: string;
+}
+export interface RozoPayTokenAmount {
+    token: RozoPayToken;
+    amount: BigIntStr;
+    usd: number;
+}
+export type OnChainCall = {
+    to: Address;
+    data: Hex;
+    value: bigint;
+};
+export declare const emptyOnChainCall: OnChainCall;
+declare const zRozoPayOrderID: z.ZodString;
+export type RozoPayOrderID = z.infer<typeof zRozoPayOrderID>;
+/**
+ * Read a base58-encoded id into a bigint.
+ */
+export declare function readRozoPayOrderID(id: string): bigint;
+/**
+ * Write a bigint into a base58-encoded id.
+ */
+export declare function writeRozoPayOrderID(id: bigint): string;
+export declare const zUUID: z.ZodString;
+export type UUID = z.infer<typeof zUUID>;
+export declare enum RozoPayEventType {
+    PaymentStarted = "payment_started",
+    PaymentCompleted = "payment_completed",
+    PaymentBounced = "payment_bounced",
+    PaymentRefunded = "payment_refunded"
+}
+export type PaymentStartedEvent = {
+    type: RozoPayEventType.PaymentStarted;
+    isTestEvent?: boolean;
+    paymentId: RozoPayOrderID;
+    chainId: number;
+    txHash: Hex | string | null;
+    payment: RozoPayOrderView;
+};
+export type PaymentCompletedEvent = {
+    type: RozoPayEventType.PaymentCompleted;
+    isTestEvent?: boolean;
+    paymentId: RozoPayOrderID;
+    chainId: number;
+    txHash: Hex;
+    payment: RozoPayOrderView;
+};
+export type PaymentBouncedEvent = {
+    type: RozoPayEventType.PaymentBounced;
+    isTestEvent?: boolean;
+    paymentId: RozoPayOrderID;
+    chainId: number;
+    txHash: Hex;
+    payment: RozoPayOrderView;
+};
+export type PaymentRefundedEvent = {
+    type: RozoPayEventType.PaymentRefunded;
+    isTestEvent?: boolean;
+    paymentId: RozoPayOrderID;
+    refundAddress: Address;
+    chainId: number;
+    tokenAddress: Address;
+    txHash: Hex;
+    amountUnits: string;
+    payment: RozoPayOrderView;
+};
+export type RozoPayEvent = PaymentStartedEvent | PaymentCompletedEvent | PaymentBouncedEvent | PaymentRefundedEvent;
+export interface WebhookEndpoint {
+    id: UUID;
+    orgId: UUID;
+    url: string;
+    token: string;
+    createdAt: Date;
+    deletedAt: Date | null;
+}
+export declare enum WebhookEventStatus {
+    PENDING = "pending",// waiting to be delivered
+    RETRYING = "retrying",// currently in exponential backoff queue
+    SUCCESSFUL = "successful",// successfully delivered
+    FAILED = "failed"
+}
+export interface WebhookEvent {
+    id: UUID;
+    endpoint: WebhookEndpoint;
+    isTestEvent: boolean;
+    body: RozoPayEvent;
+    status: WebhookEventStatus;
+    deliveries: WebhookDelivery[];
+    createdAt: Date;
+}
+export interface WebhookDelivery {
+    id: UUID;
+    eventId: UUID;
+    httpStatus: number | null;
+    body: string | null;
+    createdAt: Date;
+}
+export {};

package/dist/rozoPay.js

@@ -0,0 +1,250 @@
+"use strict";
+// TODO: this file defines types that shouldn't be exposed to the client.
+// Clean this up to only expose the types that are needed by the client.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookEventStatus = exports.RozoPayEventType = exports.zUUID = exports.emptyOnChainCall = exports.DepositAddressPaymentOptions = exports.ExternalPaymentOptions = exports.zRozoPayUserMetadata = exports.zRozoPayOrderMetadata = exports.zBridgeTokenOutOptions = exports.RozoPayIntentStatus = exports.RozoPayOrderMode = exports.RozoPayOrderStatusDest = exports.RozoPayOrderStatusSource = void 0;
+exports.isHydrated = isHydrated;
+exports.getOrderSourceChainId = getOrderSourceChainId;
+exports.getOrderDestChainId = getOrderDestChainId;
+exports.getRozoPayOrderView = getRozoPayOrderView;
+exports.readRozoPayOrderID = readRozoPayOrderID;
+exports.writeRozoPayOrderID = writeRozoPayOrderID;
+const base_1 = require("@scure/base");
+const viem_1 = require("viem");
+const zod_1 = __importDefault(require("zod"));
+const assert_1 = require("./assert");
+const primitiveTypes_1 = require("./primitiveTypes");
+// lifecycle: waiting payment -> pending processing -> start submitted -> processed (onchain tx was successful)
+var RozoPayOrderStatusSource;
+(function (RozoPayOrderStatusSource) {
+    RozoPayOrderStatusSource["WAITING_PAYMENT"] = "waiting_payment";
+    RozoPayOrderStatusSource["PENDING_PROCESSING"] = "pending_processing";
+    RozoPayOrderStatusSource["START_SUBMITTED"] = "start_submitted";
+    /* Start transaction receipt confirmed. */
+    RozoPayOrderStatusSource["PROCESSED"] = "processed";
+})(RozoPayOrderStatusSource || (exports.RozoPayOrderStatusSource = RozoPayOrderStatusSource = {}));
+// lifecycle: pending -> fast-finish-submitted (onchain tx submitted) -> fast-finished (onchain tx was successful) -> claimed (onchain tx was successful)
+var RozoPayOrderStatusDest;
+(function (RozoPayOrderStatusDest) {
+    RozoPayOrderStatusDest["PENDING"] = "pending";
+    RozoPayOrderStatusDest["FAST_FINISH_SUBMITTED"] = "fast_finish_submitted";
+    /* Fast finish transaction receipt confirmed. */
+    RozoPayOrderStatusDest["FAST_FINISHED"] = "fast_finished";
+    RozoPayOrderStatusDest["CLAIM_SUCCESSFUL"] = "claimed";
+})(RozoPayOrderStatusDest || (exports.RozoPayOrderStatusDest = RozoPayOrderStatusDest = {}));
+var RozoPayOrderMode;
+(function (RozoPayOrderMode) {
+    RozoPayOrderMode["SALE"] = "sale";
+    RozoPayOrderMode["CHOOSE_AMOUNT"] = "choose_amount";
+    RozoPayOrderMode["HYDRATED"] = "hydrated";
+})(RozoPayOrderMode || (exports.RozoPayOrderMode = RozoPayOrderMode = {}));
+/**
+ * Status values:
+ * - `payment_unpaid` - the user has not paid yet
+ * - `payment_started` - the user has paid & payment is in progress. This status
+ *    typically lasts a few seconds.
+ * - `payment_completed` - the final call or transfer succeeded
+ * - `payment_bounced` - the final call or transfer reverted. Funds were sent
+ *    to the payment's configured refund address on the destination chain.
+ */
+var RozoPayIntentStatus;
+(function (RozoPayIntentStatus) {
+    RozoPayIntentStatus["UNPAID"] = "payment_unpaid";
+    RozoPayIntentStatus["STARTED"] = "payment_started";
+    RozoPayIntentStatus["COMPLETED"] = "payment_completed";
+    RozoPayIntentStatus["BOUNCED"] = "payment_bounced";
+})(RozoPayIntentStatus || (exports.RozoPayIntentStatus = RozoPayIntentStatus = {}));
+exports.zBridgeTokenOutOptions = zod_1.default.array(zod_1.default.object({
+    token: primitiveTypes_1.zAddress,
+    amount: primitiveTypes_1.zBigIntStr.transform((a) => BigInt(a)),
+}));
+// NOTE: be careful to modify this type only in backward-compatible ways.
+//       Add OPTIONAL fields, etc. Anything else requires a migration.
+exports.zRozoPayOrderMetadata = zod_1.default.object({
+    style: zod_1.default
+        .object({
+        background: zod_1.default.string().optional().describe("Background color."),
+    })
+        .optional()
+        .describe("Style of the checkout page."),
+    orgLogo: zod_1.default.string().optional().describe("Logo of the organization."),
+    intent: zod_1.default
+        .string()
+        .describe("Title verb, eg 'Preorder', 'Check out', 'Deposit'."),
+    items: zod_1.default
+        .array(zod_1.default.object({
+        name: zod_1.default.string(),
+        description: zod_1.default.string(),
+        image: zod_1.default.string().optional(),
+        price: zod_1.default.string().optional(),
+        priceDetails: zod_1.default.string().optional(),
+    }))
+        .describe("Details about what's being ordered, donated, deposited, etc."),
+    payer: zod_1.default
+        .object({
+        preferredChains: zod_1.default
+            .array(zod_1.default.number())
+            .optional()
+            .describe("Preferred chain IDs, in descending order. Any assets the user owns on preferred chains will appear first. Defaults to destination chain."),
+        preferredTokens: zod_1.default
+            .array(zod_1.default.object({
+            chain: zod_1.default.number(),
+            address: primitiveTypes_1.zAddress.transform((a) => (0, viem_1.getAddress)(a)),
+        }))
+            .optional()
+            .describe("Preferred tokens, in descending order. Any preferred assets the user owns will appear first. Defaults to destination token."),
+        // Filter to only allow payments on these chains. Keep this
+        // parameter undocumented. Only for specific customers.
+        evmChains: zod_1.default
+            .array(zod_1.default.number())
+            .optional()
+            .describe("Filter to only allow payments on these EVM chains. Defaults to all chains."),
+        paymentOptions: zod_1.default
+            .array(zod_1.default.string())
+            .optional()
+            .describe("Payment options like Coinbase, Binance, etc. Defaults to all available options."),
+    })
+        .optional()
+        .describe(""),
+});
+/**
+ * The user-passed metadata must meet these criteria:
+ * - All keys must be strings
+ * - All values must be strings
+ * - At most 50 key-value pairs
+ * - Maximum of 40 characters per key
+ * - Maximum of 500 characters per value
+ */
+exports.zRozoPayUserMetadata = zod_1.default
+    .record(zod_1.default.string().max(40, "Metadata keys cannot be longer than 40 characters"), zod_1.default.string().max(500, "Metadata values cannot be longer than 500 characters"))
+    .nullable()
+    .refine((obj) => !obj || Object.keys(obj).length <= 50, "Metadata cannot have more than 50 key-value pairs");
+function isHydrated(order) {
+    return order.mode === RozoPayOrderMode.HYDRATED;
+}
+function getOrderSourceChainId(order) {
+    if (order.sourceTokenAmount == null) {
+        return null;
+    }
+    return order.sourceTokenAmount.token.chainId;
+}
+function getOrderDestChainId(order) {
+    return order.destFinalCallTokenAmount.token.chainId;
+}
+function getRozoPayOrderView(order) {
+    return {
+        id: writeRozoPayOrderID(order.id),
+        status: order.intentStatus,
+        createdAt: (0, assert_1.assertNotNull)(order.createdAt, `createdAt is null for order with id: ${order.id}`).toString(),
+        display: {
+            intent: order.metadata.intent,
+            // Show 2 decimal places for USD
+            paymentValue: order.destFinalCallTokenAmount.usd.toFixed(2),
+            currency: "USD",
+        },
+        source: order.mode === RozoPayOrderMode.HYDRATED &&
+            order.sourceTokenAmount != null
+            ? {
+                payerAddress: order.sourceFulfillerAddr,
+                txHash: order.sourceInitiateTxHash,
+                chainId: (0, assert_1.assertNotNull)(getOrderSourceChainId(order), `source chain id is null for order with source token: ${order.id}`).toString(),
+                amountUnits: (0, viem_1.formatUnits)(BigInt(order.sourceTokenAmount.amount), order.sourceTokenAmount.token.decimals),
+                tokenSymbol: order.sourceTokenAmount.token.symbol,
+                tokenAddress: order.sourceTokenAmount.token.token,
+            }
+            : null,
+        destination: {
+            destinationAddress: order.destFinalCall.to,
+            txHash: order.mode === RozoPayOrderMode.HYDRATED
+                ? order.destFastFinishTxHash ?? order.destClaimTxHash
+                : null,
+            chainId: getOrderDestChainId(order).toString(),
+            amountUnits: (0, viem_1.formatUnits)(BigInt(order.destFinalCallTokenAmount.amount), order.destFinalCallTokenAmount.token.decimals),
+            tokenSymbol: order.destFinalCallTokenAmount.token.symbol,
+            tokenAddress: (0, viem_1.getAddress)(order.destFinalCallTokenAmount.token.token),
+            callData: order.destFinalCall.data,
+        },
+        externalId: order.externalId,
+        metadata: order.userMetadata,
+    };
+}
+var ExternalPaymentOptions;
+(function (ExternalPaymentOptions) {
+    ExternalPaymentOptions["Rozo"] = "Rozo";
+    ExternalPaymentOptions["Coinbase"] = "Coinbase";
+    ExternalPaymentOptions["RampNetwork"] = "RampNetwork";
+    ExternalPaymentOptions["Binance"] = "Binance";
+    ExternalPaymentOptions["Solana"] = "Solana";
+    // ChangeNow chains. Bitcoin, Litecoin, Doge, Tron, etc.
+    ExternalPaymentOptions["ExternalChains"] = "ExternalChains";
+    ExternalPaymentOptions["Lemon"] = "Lemon";
+    // All available payment apps
+    ExternalPaymentOptions["AllPaymentApps"] = "AllPaymentApps";
+    ExternalPaymentOptions["Venmo"] = "Venmo";
+    ExternalPaymentOptions["CashApp"] = "CashApp";
+    ExternalPaymentOptions["MercadoPago"] = "MercadoPago";
+    ExternalPaymentOptions["Revolut"] = "Revolut";
+    ExternalPaymentOptions["Wise"] = "Wise";
+})(ExternalPaymentOptions || (exports.ExternalPaymentOptions = ExternalPaymentOptions = {}));
+var DepositAddressPaymentOptions;
+(function (DepositAddressPaymentOptions) {
+    DepositAddressPaymentOptions["TRON_USDT"] = "USDT on Tron";
+    DepositAddressPaymentOptions["BASE"] = "Base";
+    DepositAddressPaymentOptions["ARBITRUM"] = "Arbitrum";
+    DepositAddressPaymentOptions["OP_MAINNET"] = "Optimism";
+    DepositAddressPaymentOptions["POLYGON"] = "Polygon";
+    DepositAddressPaymentOptions["ETH_L1"] = "Ethereum";
+    /** @deprecated */
+    DepositAddressPaymentOptions["BITCOIN"] = "Bitcoin";
+    /** @deprecated */
+    DepositAddressPaymentOptions["TON"] = "TON";
+    /** @deprecated */
+    DepositAddressPaymentOptions["MONERO"] = "Monero";
+    /** @deprecated */
+    DepositAddressPaymentOptions["DOGE"] = "Doge";
+    /** @deprecated */
+    DepositAddressPaymentOptions["LITECOIN"] = "Litecoin";
+    /** @deprecated */
+    DepositAddressPaymentOptions["ZCASH"] = "Zcash";
+    /** @deprecated */
+    DepositAddressPaymentOptions["DASH"] = "Dash";
+})(DepositAddressPaymentOptions || (exports.DepositAddressPaymentOptions = DepositAddressPaymentOptions = {}));
+exports.emptyOnChainCall = {
+    to: viem_1.zeroAddress,
+    data: "0x",
+    value: 0n,
+};
+// base58 encoded bigint
+const zRozoPayOrderID = zod_1.default.string().regex(/^[1-9A-HJ-NP-Za-km-z]+$/);
+/**
+ * Read a base58-encoded id into a bigint.
+ */
+function readRozoPayOrderID(id) {
+    return (0, viem_1.bytesToBigInt)(base_1.base58.decode(id));
+}
+/**
+ * Write a bigint into a base58-encoded id.
+ */
+function writeRozoPayOrderID(id) {
+    return base_1.base58.encode((0, viem_1.numberToBytes)(id));
+}
+exports.zUUID = zod_1.default.string().uuid();
+var RozoPayEventType;
+(function (RozoPayEventType) {
+    RozoPayEventType["PaymentStarted"] = "payment_started";
+    RozoPayEventType["PaymentCompleted"] = "payment_completed";
+    RozoPayEventType["PaymentBounced"] = "payment_bounced";
+    RozoPayEventType["PaymentRefunded"] = "payment_refunded";
+})(RozoPayEventType || (exports.RozoPayEventType = RozoPayEventType = {}));
+// Lifecycle: Pending (just created) -> (if failing) Retrying (exponential backoff) -> Successful or Failed
+var WebhookEventStatus;
+(function (WebhookEventStatus) {
+    WebhookEventStatus["PENDING"] = "pending";
+    WebhookEventStatus["RETRYING"] = "retrying";
+    WebhookEventStatus["SUCCESSFUL"] = "successful";
+    WebhookEventStatus["FAILED"] = "failed";
+})(WebhookEventStatus || (exports.WebhookEventStatus = WebhookEventStatus = {}));
+//# sourceMappingURL=rozoPay.js.map