@p2pdotme/sdk 1.0.5 → 1.1.1

package/dist/orders.d.ts

@@ -0,0 +1,620 @@
+import { ResultAsync } from 'neverthrow';
+import { Address, WalletClient, TransactionReceipt } from 'viem';
+import { z } from 'zod';
+
+/**
+ * Minimal viem PublicClient interface — consumers pass their own client.
+ * The SDK uses `readContract` for single reads and `multicall` where available
+ * to batch multiple reads into one RPC round-trip.
+ */
+interface PublicClientLike {
+    readContract(args: {
+        address: Address;
+        abi: readonly unknown[];
+        functionName: string;
+        args: readonly unknown[];
+    }): Promise<unknown>;
+    multicall?(args: {
+        contracts: readonly {
+            address: Address;
+            abi: readonly unknown[];
+            functionName: string;
+            args?: readonly unknown[];
+        }[];
+        allowFailure?: boolean;
+    }): Promise<readonly unknown[]>;
+}
+
+declare class SdkError<TCode extends string = string> extends Error {
+    readonly code: TCode;
+    readonly cause?: unknown;
+    readonly context?: Record<string, unknown>;
+    constructor(message: string, options: {
+        code: TCode;
+        cause?: unknown;
+        context?: Record<string, unknown>;
+    });
+}
+
+type OrdersErrorCode = "VALIDATION_ERROR" | "INVALID_ORDER_ID" | "INVALID_GET_ORDERS_PARAMS" | "INVALID_FEE_CONFIG_PARAMS" | "ORDER_NOT_FOUND" | "CONTRACT_READ_FAILED" | "SUBGRAPH_REQUEST_FAILED" | "SUBGRAPH_VALIDATION_FAILED" | "MALFORMED_ORDER" | "CIRCLE_SELECTION_FAILED" | "ENCRYPTION_FAILED" | "RELAY_IDENTITY_CORRUPT" | "RELAY_IDENTITY_STORE_FAILED" | "TX_SUBMISSION_FAILED" | "RECEIPT_TIMEOUT" | "TX_REVERTED" | "EVENT_WATCH_FAILED";
+declare class OrdersError extends SdkError<OrdersErrorCode> {
+    constructor(message: string, options: {
+        code: OrdersErrorCode;
+        cause?: unknown;
+        context?: Record<string, unknown>;
+    });
+}
+
+interface Logger {
+    debug(message: string, data?: Record<string, unknown>): void;
+    info(message: string, data?: Record<string, unknown>): void;
+    warn(message: string, data?: Record<string, unknown>): void;
+    error(message: string, data?: Record<string, unknown>): void;
+}
+
+interface RelayIdentity {
+    readonly address: `0x${string}`;
+    readonly publicKey: string;
+    readonly privateKey: `0x${string}`;
+}
+/**
+ * Generates a fresh relay identity keypair. Pure — no side effects.
+ * Consumers decide how to persist the result via a `RelayIdentityStore`.
+ */
+declare function createRelayIdentity(): RelayIdentity;
+
+interface RelayIdentityStore {
+    get(): Promise<RelayIdentity | null>;
+    set(identity: RelayIdentity): Promise<void>;
+}
+/**
+ * Ephemeral in-process store. Lost on process restart. Used as the default
+ * when the consumer doesn't supply one.
+ */
+declare function createInMemoryRelayStore(): RelayIdentityStore;
+/**
+ * Browser-only adapter that persists the identity as JSON in `localStorage`.
+ * Throws at call time if `localStorage` is unavailable — do not use in SSR/RN.
+ */
+declare function createLocalStorageRelayStore(options?: {
+    key?: string;
+}): RelayIdentityStore;
+
+declare const ZodGetOrderParamsSchema: z.ZodObject<{
+    orderId: z.ZodBigInt;
+}, z.core.$strip>;
+type GetOrderParams = z.infer<typeof ZodGetOrderParamsSchema>;
+declare const ZodGetFeeConfigParamsSchema: z.ZodObject<{
+    currency: z.ZodEnum<{
+        IDR: "IDR";
+        INR: "INR";
+        BRL: "BRL";
+        ARS: "ARS";
+        MEX: "MEX";
+        VEN: "VEN";
+        EUR: "EUR";
+        NGN: "NGN";
+        USD: "USD";
+        COP: "COP";
+    }>;
+}, z.core.$strip>;
+type GetFeeConfigParams = z.infer<typeof ZodGetFeeConfigParamsSchema>;
+declare const ZodGetOrdersParamsSchema: z.ZodObject<{
+    userAddress: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+    skip: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type GetOrdersParams = z.input<typeof ZodGetOrdersParamsSchema>;
+declare const ZodPlaceOrderParamsSchema: z.ZodObject<{
+    orderType: z.ZodNumber;
+    currency: z.ZodEnum<{
+        IDR: "IDR";
+        INR: "INR";
+        BRL: "BRL";
+        ARS: "ARS";
+        MEX: "MEX";
+        VEN: "VEN";
+        EUR: "EUR";
+        NGN: "NGN";
+        USD: "USD";
+        COP: "COP";
+    }>;
+    user: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+    amount: z.ZodBigInt;
+    fiatAmount: z.ZodBigInt;
+    fiatAmountLimit: z.ZodDefault<z.ZodOptional<z.ZodBigInt>>;
+    recipientAddr: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+    preferredPaymentChannelConfigId: z.ZodOptional<z.ZodBigInt>;
+    pubKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type PlaceOrderParams = z.input<typeof ZodPlaceOrderParamsSchema>;
+declare const ZodCancelOrderParamsSchema: z.ZodObject<{
+    orderId: z.ZodBigInt;
+}, z.core.$strip>;
+type CancelOrderParams = z.infer<typeof ZodCancelOrderParamsSchema>;
+declare const ZodSetSellOrderUpiParamsSchema: z.ZodObject<{
+    orderId: z.ZodBigInt;
+    paymentAddress: z.ZodString;
+    merchantPublicKey: z.ZodString;
+    updatedAmount: z.ZodBigInt;
+}, z.core.$strip>;
+type SetSellOrderUpiParams = z.infer<typeof ZodSetSellOrderUpiParamsSchema>;
+declare const ZodRaiseDisputeParamsSchema: z.ZodObject<{
+    orderId: z.ZodBigInt;
+    redactTransId: z.ZodBigInt;
+}, z.core.$strip>;
+type RaiseDisputeParams = z.infer<typeof ZodRaiseDisputeParamsSchema>;
+declare const ZodApproveUsdcParamsSchema: z.ZodObject<{
+    amount: z.ZodBigInt;
+}, z.core.$strip>;
+type ApproveUsdcParams = z.infer<typeof ZodApproveUsdcParamsSchema>;
+declare const ZodPaidBuyOrderParamsSchema: z.ZodObject<{
+    orderId: z.ZodBigInt;
+}, z.core.$strip>;
+type PaidBuyOrderParams = z.infer<typeof ZodPaidBuyOrderParamsSchema>;
+
+type OrderType = "buy" | "sell" | "pay";
+type OrderStatus = "placed" | "accepted" | "paid" | "completed" | "cancelled";
+type DisputeStatus = "none" | "open" | "resolved";
+/**
+ * Normalized order record returned by both `getOrder` and `getOrders`.
+ * Amounts are 6-decimal bigints; timestamps are unix seconds.
+ */
+interface Order {
+    orderId: bigint;
+    type: OrderType;
+    status: OrderStatus;
+    usdcAmount: bigint;
+    fiatAmount: bigint;
+    actualUsdcAmount: bigint;
+    actualFiatAmount: bigint;
+    currency: string;
+    user: Address;
+    recipient: Address;
+    acceptedMerchant: Address;
+    placedAt: bigint;
+    acceptedAt: bigint;
+    paidAt: bigint;
+    completedAt: bigint;
+    circleId: bigint;
+    fixedFeePaid: bigint;
+    tipsPaid: bigint;
+    disputeStatus: DisputeStatus;
+    /**
+     * Encrypted UPI / payment address that the merchant published for this order
+     * (set when the merchant accepts a buy order). Empty string until set.
+     * Decrypt with `decryptPaymentAddress`.
+     */
+    encUpi: string;
+    /**
+     * Encrypted merchant UPI for the seller-side flow (set by `setSellOrderUpi`).
+     * Empty string until set.
+     */
+    encMerchantUpi: string;
+    /** Public key associated with the order, used for ECIES encryption setup. */
+    pubkey: string;
+}
+/**
+ * Per-currency small-order fee config read from the Diamond.
+ * Amounts are 6-decimal bigints.
+ */
+interface FeeConfig {
+    /** Order amounts at or below this threshold are billed the fixed fee. */
+    smallOrderThreshold: bigint;
+    /** Fixed fee applied to small orders (6 decimals). */
+    smallOrderFixedFee: bigint;
+}
+interface OrdersConfig {
+    readonly publicClient: PublicClientLike;
+    readonly diamondAddress: Address;
+    readonly usdcAddress: Address;
+    readonly subgraphUrl: string;
+    readonly relayIdentityStore?: RelayIdentityStore;
+    readonly relayIdentity?: RelayIdentity;
+    readonly logger?: Logger;
+}
+interface PreparedTxMeta {
+    readonly circleId?: bigint;
+    readonly relayIdentity?: RelayIdentity;
+}
+interface PreparedTx {
+    readonly to: `0x${string}`;
+    readonly data: `0x${string}`;
+    readonly value: bigint;
+    readonly meta?: PreparedTxMeta;
+}
+interface TxResultMeta extends PreparedTxMeta {
+    /**
+     * Populated on `placeOrder.execute({ waitForReceipt: true })` — the orderId
+     * parsed from the `OrderPlaced` event in the receipt's logs. Undefined when
+     * `waitForReceipt` is not set (no receipt means no logs to parse).
+     */
+    readonly orderId?: bigint;
+}
+interface TxResult {
+    readonly hash: `0x${string}`;
+    readonly receipt?: TransactionReceipt;
+    readonly meta?: TxResultMeta;
+}
+interface ExecuteBase {
+    readonly walletClient: WalletClient;
+    readonly waitForReceipt?: boolean;
+}
+type OrderEvent = {
+    readonly type: "placed";
+    readonly orderId: bigint;
+    readonly user: Address;
+    readonly orderType: 0 | 1 | 2;
+    readonly blockNumber: bigint;
+    readonly txHash: `0x${string}`;
+} | {
+    readonly type: "accepted";
+    readonly orderId: bigint;
+    readonly merchant: Address;
+    readonly blockNumber: bigint;
+    readonly txHash: `0x${string}`;
+} | {
+    readonly type: "paid";
+    readonly orderId: bigint;
+    readonly blockNumber: bigint;
+    readonly txHash: `0x${string}`;
+} | {
+    readonly type: "completed";
+    readonly orderId: bigint;
+    readonly blockNumber: bigint;
+    readonly txHash: `0x${string}`;
+} | {
+    readonly type: "cancelled";
+    readonly orderId: bigint;
+    readonly blockNumber: bigint;
+    readonly txHash: `0x${string}`;
+};
+
+interface ApproveUsdcAction {
+    prepare(params: ApproveUsdcParams): ResultAsync<PreparedTx, OrdersError>;
+    execute(params: ApproveUsdcParams & ExecuteBase): ResultAsync<TxResult, OrdersError>;
+}
+
+interface CancelOrderAction {
+    prepare(params: CancelOrderParams): ResultAsync<PreparedTx, OrdersError>;
+    execute(params: CancelOrderParams & ExecuteBase): ResultAsync<TxResult, OrdersError>;
+}
+
+interface PaidBuyOrderAction {
+    prepare(params: PaidBuyOrderParams): ResultAsync<PreparedTx, OrdersError>;
+    execute(params: PaidBuyOrderParams & ExecuteBase): ResultAsync<TxResult, OrdersError>;
+}
+
+interface PlaceOrderAction {
+    prepare(params: PlaceOrderParams): ResultAsync<PreparedTx, OrdersError>;
+    execute(params: PlaceOrderParams & ExecuteBase): ResultAsync<TxResult, OrdersError>;
+}
+
+interface RaiseDisputeAction {
+    prepare(params: RaiseDisputeParams): ResultAsync<PreparedTx, OrdersError>;
+    execute(params: RaiseDisputeParams & ExecuteBase): ResultAsync<TxResult, OrdersError>;
+}
+
+interface SetSellOrderUpiAction {
+    prepare(params: SetSellOrderUpiParams): ResultAsync<PreparedTx, OrdersError>;
+    execute(params: SetSellOrderUpiParams & ExecuteBase): ResultAsync<TxResult, OrdersError>;
+}
+
+interface WatchEventsParams {
+    readonly user?: Address;
+    readonly onEvent: (event: OrderEvent) => void;
+    readonly onError?: (error: OrdersError) => void;
+}
+type WatchEvents = (params: WatchEventsParams) => () => void;
+
+interface OrdersClient {
+    /** Reads a single order by id from the Diamond contract. */
+    getOrder(params: GetOrderParams): ResultAsync<Order, OrdersError>;
+    /**
+     * Lists orders created by `userAddress` from the subgraph, newest first.
+     * Defaults: `skip = 0`, `limit = 20`. Max `limit` is 100.
+     */
+    getOrders(params: GetOrdersParams): ResultAsync<Order[], OrdersError>;
+    /**
+     * Reads the per-currency small-order fee config from the Diamond via
+     * multicall: threshold (below which the fixed fee applies) and the fixed
+     * fee itself. Both are 6-decimal bigints.
+     */
+    getFeeConfig(params: GetFeeConfigParams): ResultAsync<FeeConfig, OrdersError>;
+    readonly placeOrder: PlaceOrderAction;
+    readonly cancelOrder: CancelOrderAction;
+    readonly setSellOrderUpi: SetSellOrderUpiAction;
+    readonly raiseDispute: RaiseDisputeAction;
+    readonly approveUsdc: ApproveUsdcAction;
+    readonly paidBuyOrder: PaidBuyOrderAction;
+    watchEvents: WatchEvents;
+    /**
+     * Decrypts an `encUpi` / `encMerchantUpi` ciphertext from an order using the
+     * relay identity resolved from the configured store. Returns the plaintext
+     * payment address.
+     */
+    decryptPaymentAddress(params: {
+        encrypted: string;
+    }): ResultAsync<string, OrdersError>;
+    /**
+     * Signs `paymentAddress` with the resolved relay identity and ECIES-encrypts
+     * the payload for `recipientPublicKey`. Returns the hex-stringified ciphertext
+     * suitable for on-chain storage (e.g. as the merchant's encUpi when calling
+     * `setSellOrderUpi`).
+     */
+    encryptPaymentAddress(params: {
+        paymentAddress: string;
+        recipientPublicKey: string;
+    }): ResultAsync<string, OrdersError>;
+}
+/**
+ * Creates the unified orders client — reads (getOrder, getOrders, getFeeConfig)
+ * and circle-routing-backed writes (placeOrder, cancelOrder, setSellOrderUpi,
+ * raiseDispute, approveUsdc). The relay identity store defaults to in-memory
+ * when none is supplied.
+ *
+ * For USDC balance / allowance reads use `@p2pdotme/sdk/profile` (those are
+ * user-scoped and live there).
+ */
+declare function createOrders(config: OrdersConfig): OrdersClient;
+
+/**
+ * Centralized contract error definitions mirroring `contracts/libraries/Errors.sol`.
+ * Maps Solidity custom error names and their 4-byte selectors to human-readable codes.
+ */
+declare const contractErrors: {
+    readonly NotAdmin: "NOT_ADMIN";
+    readonly NotSuperAdmin: "NOT_SUPER_ADMIN";
+    readonly NotAuthorized: "NOT_AUTHORIZED";
+    readonly NotSelf: "NOT_SELF";
+    readonly NotWhitelisted: "NOT_WHITELISTED";
+    readonly NotCircleAdmin: "NOT_CIRCLE_ADMIN";
+    readonly InvalidName: "INVALID_NAME";
+    readonly InvalidCommunityUrl: "INVALID_COMMUNITY_URL";
+    readonly InvalidAdminCommunityUrl: "INVALID_ADMIN_COMMUNITY_URL";
+    readonly AdminAlreadyHasCircle: "ADMIN_ALREADY_HAS_CIRCLE";
+    readonly CircleNameAlreadyTaken: "CIRCLE_NAME_ALREADY_TAKEN";
+    readonly P2PStakeConfigNotSet: "P2P_STAKE_CONFIG_NOT_SET";
+    readonly InsufficientP2PStake: "INSUFFICIENT_P2P_STAKE";
+    readonly P2PTokenNotSet: "P2P_TOKEN_NOT_SET";
+    readonly P2PUnstakeRequestPending: "P2P_UNSTAKE_REQUEST_PENDING";
+    readonly NoP2PUnstakeRequest: "NO_P2P_UNSTAKE_REQUEST";
+    readonly P2PUnstakeCooldownNotPassed: "P2P_UNSTAKE_COOLDOWN_NOT_PASSED";
+    readonly SlashAmountExceedsStake: "SLASH_AMOUNT_EXCEEDS_STAKE";
+    readonly CircleNotActive: "CIRCLE_NOT_ACTIVE";
+    readonly InvalidCircleId: "INVALID_CIRCLE_ID";
+    readonly CurrencyMismatch: "CURRENCY_MISMATCH";
+    readonly CircleFull: "CIRCLE_FULL";
+    readonly CircleIdMismatch: "CIRCLE_ID_MISMATCH";
+    readonly DuplicateAccountName: "DUPLICATE_ACCOUNT_NAME";
+    readonly EmptyName: "EMPTY_NAME";
+    readonly AccountBoundToAnotherCircle: "ACCOUNT_BOUND_TO_ANOTHER_CIRCLE";
+    readonly ExitAmountExceededCircleBalance: "EXIT_AMOUNT_EXCEEDED_CIRCLE_BALANCE";
+    readonly UndelegationAmountTooHigh: "UNDELEGATION_AMOUNT_TOO_HIGH";
+    readonly ExchangeNotOperational: "EXCHANGE_NOT_OPERATIONAL";
+    readonly OrderNotPlaced: "ORDER_NOT_PLACED";
+    readonly OrderNotPaid: "ORDER_NOT_PAID";
+    readonly OrderStatusInvalid: "ORDER_STATUS_INVALID";
+    readonly OrderExpired: "ORDER_EXPIRED";
+    readonly OrderAlreadyPaid: "ORDER_ALREADY_PAID";
+    readonly OrderAlreadyCompleted: "ORDER_ALREADY_COMPLETED";
+    readonly InvalidOrderType: "INVALID_ORDER_TYPE";
+    readonly OrderTypeIncorrect: "ORDER_TYPE_INCORRECT";
+    readonly OrderNotAccepted: "ORDER_NOT_ACCEPTED";
+    readonly OrderNotAssigned: "ORDER_NOT_ASSIGNED";
+    readonly OrderAmountExceedsLimit: "ORDER_AMOUNT_EXCEEDS_LIMIT";
+    readonly InvalidOrderAmount: "INVALID_ORDER_AMOUNT";
+    readonly InvalidOrderAmountToCoverFee: "INVALID_ORDER_AMOUNT_TO_COVER_FEE";
+    readonly InvalidOrderId: "INVALID_ORDER_ID";
+    readonly OrderTooEarlyForReassignment: "ORDER_TOO_EARLY_FOR_REASSIGNMENT";
+    readonly OrderTooLateForReassignment: "ORDER_TOO_LATE_FOR_REASSIGNMENT";
+    readonly ReAssignmentNotRequired: "REASSIGNMENT_NOT_REQUIRED";
+    readonly TipAlreadyGiven: "TIP_ALREADY_GIVEN";
+    readonly CashbackTransferFailed: "CASHBACK_TRANSFER_FAILED";
+    readonly DailyBuyOrderLimitExceeded: "DAILY_BUY_ORDER_LIMIT_EXCEEDED";
+    readonly MonthlyBuyOrderLimitExceeded: "MONTHLY_BUY_ORDER_LIMIT_EXCEEDED";
+    readonly SellOrderAmountLimitExceeded: "SELL_ORDER_AMOUNT_LIMIT_EXCEEDED";
+    readonly BuyOrderAmountExceedsLimit: "BUY_ORDER_AMOUNT_EXCEEDS_LIMIT";
+    readonly SellOrderAmountExceedsLimit: "SELL_ORDER_AMOUNT_EXCEEDS_LIMIT";
+    readonly BuyAmountExceedsUsdcLimit: "BUY_AMOUNT_EXCEEDS_USDC_LIMIT";
+    readonly SellAmountExceedsFiatLimit: "SELL_AMOUNT_EXCEEDS_FIAT_LIMIT";
+    readonly DailyVolumeLimitExceeded: "DAILY_VOLUME_LIMIT_EXCEEDED";
+    readonly MonthlyVolumeLimitExceeded: "MONTHLY_VOLUME_LIMIT_EXCEEDED";
+    readonly UserYearlyVolumeLimitExceeded: "USER_YEARLY_VOLUME_LIMIT_EXCEEDED";
+    readonly DisputeTimeNotReached: "DISPUTE_TIME_NOT_REACHED";
+    readonly DisputeTimeExpired: "DISPUTE_TIME_EXPIRED";
+    readonly InvalidOrderStatusToRaiseDispute: "INVALID_ORDER_STATUS_TO_RAISE_DISPUTE";
+    readonly DisputeNotRaised: "DISPUTE_NOT_RAISED";
+    readonly CannotRaiseDisputeTwice: "CANNOT_RAISE_DISPUTE_TWICE";
+    readonly DisputeAlreadySettled: "DISPUTE_ALREADY_SETTLED";
+    readonly TransactionIdMismatch: "TRANSACTION_ID_MISMATCH";
+    readonly AccountNumberMismatch: "ACCOUNT_NUMBER_MISMATCH";
+    readonly NotPaidBuyOrder: "NOT_PAID_BUY_ORDER";
+    readonly PaymentChannelNotFound: "PAYMENT_CHANNEL_NOT_FOUND";
+    readonly PaymentChannelNotActive: "PAYMENT_CHANNEL_NOT_ACTIVE";
+    readonly PaymentChannelNotApproved: "PAYMENT_CHANNEL_NOT_APPROVED";
+    readonly PaymentChannelNotRejected: "PAYMENT_CHANNEL_NOT_REJECTED";
+    readonly InvalidPaymentChannelId: "INVALID_PAYMENT_CHANNEL_ID";
+    readonly DuplicatePaymentChannel: "DUPLICATE_PAYMENT_CHANNEL";
+    readonly OldPaymentChannelNotFound: "OLD_PAYMENT_CHANNEL_NOT_FOUND";
+    readonly NewPaymentChannelNotFound: "NEW_PAYMENT_CHANNEL_NOT_FOUND";
+    readonly SamePaymentChannel: "SAME_PAYMENT_CHANNEL";
+    readonly OldPaymentChannelShouldBeInactive: "OLD_PAYMENT_CHANNEL_SHOULD_BE_INACTIVE";
+    readonly NewPaymentChannelShouldBeActive: "NEW_PAYMENT_CHANNEL_SHOULD_BE_ACTIVE";
+    readonly OngoingOrderOnPaymentChannel: "ONGOING_ORDER_ON_PAYMENT_CHANNEL";
+    readonly UpiAlreadySent: "UPI_ALREADY_SENT";
+    readonly InvalidOrderUpi: "INVALID_ORDER_UPI";
+    readonly NoFiatLiquidity: "NO_FIAT_LIQUIDITY";
+    readonly NotEnoughEligibleMerchants: "NOT_ENOUGH_ELIGIBLE_MERCHANTS";
+    readonly MerchantNotRegistered: "MERCHANT_NOT_REGISTERED";
+    readonly MerchantNotApproved: "MERCHANT_NOT_APPROVED";
+    readonly MerchantAlreadyRegistered: "MERCHANT_ALREADY_REGISTERED";
+    readonly MerchantAlreadyRejected: "MERCHANT_ALREADY_REJECTED";
+    readonly MerchantBlacklisted: "MERCHANT_BLACKLISTED";
+    readonly MerchantNotBlacklisted: "MERCHANT_NOT_BLACKLISTED";
+    readonly MerchantAlreadyBlacklisted: "MERCHANT_ALREADY_BLACKLISTED";
+    readonly MerchantHasOngoingOrders: "MERCHANT_HAS_ONGOING_ORDERS";
+    readonly MerchantNotFullfilledEligibilityThreshold: "MERCHANT_NOT_FULLFILLED_ELIGIBILITY_THRESHOLD";
+    readonly InvalidMerchant: "INVALID_MERCHANT";
+    readonly StakeAmountTooLow: "STAKE_AMOUNT_TOO_LOW";
+    readonly AdditionalStakeNotAllowed: "ADDITIONAL_STAKE_NOT_ALLOWED";
+    readonly UnstakeRequestPending: "UNSTAKE_REQUEST_PENDING";
+    readonly UnstakeRequestNotPending: "UNSTAKE_REQUEST_NOT_PENDING";
+    readonly UnstakeAmountExceeded: "UNSTAKE_AMOUNT_EXCEEDED";
+    readonly ZeroUnstakeAmount: "ZERO_UNSTAKE_AMOUNT";
+    readonly NoWithdrawableAmount: "NO_WITHDRAWABLE_AMOUNT";
+    readonly NoStake: "NO_STAKE";
+    readonly NoStakers: "NO_STAKERS";
+    readonly InsufficientStakedAmount: "INSUFFICIENT_STAKED_AMOUNT";
+    readonly CooldownNotPassed: "COOLDOWN_NOT_PASSED";
+    readonly ClaimableRewardsNotAvailable: "CLAIMABLE_REWARDS_NOT_AVAILABLE";
+    readonly ExitWouldBreachDelegationInvariant: "EXIT_WOULD_BREACH_DELEGATION_INVARIANT";
+    readonly AggregateDelegationExceedsTotalStaked: "AGGREGATE_DELEGATION_EXCEEDS_TOTAL_STAKED";
+    readonly InsufficientMerchantRewards: "INSUFFICIENT_MERCHANT_REWARDS";
+    readonly InvalidMigrationStatus: "INVALID_MIGRATION_STATUS";
+    readonly MigrationRequestNotPending: "MIGRATION_REQUEST_NOT_PENDING";
+    readonly MigrationAlreadyRequested: "MIGRATION_ALREADY_REQUESTED";
+    readonly TokenAlreadyExists: "TOKEN_ALREADY_EXISTS";
+    readonly TokenNotFound: "TOKEN_NOT_FOUND";
+    readonly TokenEmpty: "TOKEN_EMPTY";
+    readonly CurrencyNotSupported: "CURRENCY_NOT_SUPPORTED";
+    readonly InvalidCurrency: "INVALID_CURRENCY";
+    readonly UsdtTransferFailed: "USDC_TRANSFER_FAILED";
+    readonly UsdtTransferFailedWithErrorMessage: "USDC_TRANSFER_FAILED_WITH_ERROR_MESSAGE";
+    readonly UsdtTransferFailedWithPanic: "USDC_TRANSFER_FAILED_WITH_PANIC";
+    readonly InsufficientAllowance: "INSUFFICIENT_ALLOWANCE";
+    readonly ZKPassportVerifierNotSet: "ZK_PASSPORT_VERIFIER_NOT_SET";
+    readonly ZKPassportDomainEmpty: "ZK_PASSPORT_DOMAIN_EMPTY";
+    readonly ZKPassportScopeEmpty: "ZK_PASSPORT_SCOPE_EMPTY";
+    readonly PassportAlreadyVerified: "PASSPORT_ALREADY_VERIFIED";
+    readonly ZKPassportProofInvalid: "ZK_PASSPORT_PROOF_INVALID";
+    readonly ZKPassportIdentifierAlreadyVerified: "ZK_PASSPORT_IDENTIFIER_ALREADY_VERIFIED";
+    readonly ZKPassportInvalidScope: "ZK_PASSPORT_INVALID_SCOPE";
+    readonly ZKPassportUnexpectedSender: "ZK_PASSPORT_UNEXPECTED_SENDER";
+    readonly ZKPassportAgeBelowMinimum: "ZK_PASSPORT_AGE_BELOW_MINIMUM";
+    readonly ZKPassportMinAgeTooHigh: "ZK_PASSPORT_MIN_AGE_TOO_HIGH";
+    readonly UnexpectedRequestId: "UNEXPECTED_REQUEST_ID";
+    readonly OnlyRouterCanFulfill: "ONLY_ROUTER_CAN_FULFILL";
+    readonly RequestFailed: "REQUEST_FAILED";
+    readonly SourceCodeMismatch: "SOURCE_CODE_MISMATCH";
+    readonly ZeroMarketPrice: "ZERO_MARKET_PRICE";
+    readonly InvalidComputedPrices: "INVALID_COMPUTED_PRICES";
+    readonly NotPriceUpdaterForCurrency: "NOT_PRICE_UPDATER_FOR_CURRENCY";
+    readonly ThresholdNotConfigured: "THRESHOLD_NOT_CONFIGURED";
+    readonly SlippageExceeded: "SLIPPAGE_EXCEEDED";
+    readonly UserHasNoReputation: "USER_HAS_NO_REPUTATION";
+    readonly ZeroReputationPoints: "ZERO_REPUTATION_POINTS";
+    readonly NoReputation: "NO_REPUTATION";
+    readonly InsufficientRP: "INSUFFICIENT_RP";
+    readonly NullifierAlreadyVerified: "NULLIFIER_ALREADY_VERIFIED";
+    readonly VerificationFailed: "VERIFICATION_FAILED";
+    readonly InvalidSocialPlatform: "INVALID_SOCIAL_PLATFORM";
+    readonly SocialAlreadyVerified: "SOCIAL_ALREADY_VERIFIED";
+    readonly YearFieldNotInProof: "YEAR_FIELD_NOT_IN_PROOF";
+    readonly UserIdFieldNotInProof: "USER_ID_FIELD_NOT_IN_PROOF";
+    readonly UserIdAlreadyVerified: "USER_ID_ALREADY_VERIFIED";
+    readonly UsernameAlreadyVerified: "USERNAME_ALREADY_VERIFIED";
+    readonly UsernameNotInProof: "USERNAME_NOT_IN_PROOF";
+    readonly LinkedInOnlyRpUpdates: "LINKEDIN_ONLY_RP_UPDATES";
+    readonly FacebookOnlyRpUpdates: "FACEBOOK_ONLY_RP_UPDATES";
+    readonly AlreadyReferred: "ALREADY_REFERRED";
+    readonly SelfReferralNotAllowed: "SELF_REFERRAL_NOT_ALLOWED";
+    readonly NotEligibleToRefer: "NOT_ELIGIBLE_TO_REFER";
+    readonly MerchantMonthlyReferralLimitReached: "MERCHANT_MONTHLY_REFERRAL_LIMIT_REACHED";
+    readonly NoRecommender: "NO_RECOMMENDER";
+    readonly RecommendationAlreadyClaimed: "RECOMMENDATION_ALREADY_CLAIMED";
+    readonly CannotVoteYourself: "CANNOT_VOTE_YOURSELF";
+    readonly VotesPerEpochExceeded: "VOTES_PER_EPOCH_EXCEEDED";
+    readonly AlreadyVoted: "ALREADY_VOTED";
+    readonly FunctionNotFound: "FUNCTION_NOT_FOUND";
+    readonly CampaignNotActive: "CAMPAIGN_NOT_ACTIVE";
+    readonly InvalidManagerDetails: "INVALID_MANAGER_DETAILS";
+    readonly UnclaimedRewardsExist: "UNCLAIMED_REWARDS_EXIST";
+    readonly RewardAlreadyClaimed: "REWARD_ALREADY_CLAIMED";
+    readonly OnlyNewUsersAllowed: "ONLY_NEW_USERS_ALLOWED";
+    readonly ManagerNotFound: "MANAGER_NOT_FOUND";
+    readonly ManagerInactive: "MANAGER_INACTIVE";
+    readonly NoRewards: "NO_REWARDS";
+    readonly InvalidCampaignId: "INVALID_CAMPAIGN_ID";
+    readonly CannotClaimRevenueForCurrentMonth: "CANNOT_CLAIM_REVENUE_FOR_CURRENT_MONTH";
+    readonly RewardPercentageTooHigh: "REWARD_PERCENTAGE_TOO_HIGH";
+    readonly NonceAlreadyUsed: "NONCE_ALREADY_USED";
+    readonly SignatureValidationFailed: "SIGNATURE_VALIDATION_FAILED";
+    readonly InvalidAddress: "INVALID_ADDRESS";
+    readonly InvalidBlockAmount: "INVALID_BLOCK_AMOUNT";
+    readonly InvalidAmount: "INVALID_AMOUNT";
+    readonly InvalidInput: "INVALID_INPUT";
+    readonly InvalidStatusTransition: "INVALID_STATUS_TRANSITION";
+    readonly ArrayLengthMismatch: "ARRAY_LENGTH_MISMATCH";
+    readonly UserIsBlacklisted: "USER_IS_BLACKLISTED";
+    readonly ZeroAddress: "ZERO_ADDRESS";
+    readonly ReentrancyGuard: "REENTRANCY_GUARD";
+    readonly BatchTooLarge: "BATCH_TOO_LARGE";
+    readonly UnderflowSubtraction: "UNDERFLOW_SUBTRACTION";
+    readonly TargetLongerThanData: "TARGET_LONGER_THAN_DATA";
+};
+type ContractErrorCode = (typeof contractErrors)[keyof typeof contractErrors];
+/** Maps 4-byte Solidity custom error selectors to their error codes. */
+declare const hexContractErrors: Record<string, ContractErrorCode>;
+/**
+ * Parses an unknown contract revert into a `ContractErrorCode` string.
+ * Inspects hex selectors in `data`, `message`, and nested `cause` fields.
+ * Returns `null` if no known error is matched.
+ */
+declare function parseContractError(error: unknown): ContractErrorCode | null;
+
+/**
+ * English UI strings for every contract error code.
+ * Pass a `ContractErrorCode` to `getContractErrorMessage` to get a
+ * human-readable string safe to display directly in the UI.
+ */
+declare const contractErrorMessages: Record<ContractErrorCode, string>;
+/**
+ * Returns a human-readable English string for the given `ContractErrorCode`,
+ * or a generic fallback message if the code is not recognised.
+ *
+ * @example
+ * const msg = getContractErrorMessage("USERNAME_ALREADY_VERIFIED");
+ * // "The social media account's username is already verified"
+ */
+declare function getContractErrorMessage(code: ContractErrorCode | string | null | undefined, fallback?: string): string;
+
+interface Encrypted {
+    readonly iv: string;
+    readonly ephemPublicKey: string;
+    readonly ciphertext: string;
+    readonly mac: string;
+}
+/**
+ * Serializes an Encrypted object to a compact hex string.
+ * Format: IV (16 bytes) || compressed ephemPublicKey (33 bytes) || MAC (32 bytes) || ciphertext.
+ */
+declare function cipherStringify(encrypted: Encrypted): string;
+/**
+ * Parses a compact hex string back into an Encrypted object.
+ * Inverse of cipherStringify.
+ */
+declare function cipherParse(str: string): Encrypted;
+
+interface EncryptPaymentAddressInput {
+    readonly paymentAddress: string;
+    readonly recipientPublicKey: string;
+    readonly senderIdentity: RelayIdentity;
+}
+/**
+ * Signs `paymentAddress` with the sender relay identity's private key, then
+ * ECIES-encrypts the `{ message, signature }` payload for the recipient. Returns
+ * the hex-stringified ciphertext suitable for on-chain storage.
+ */
+declare function encryptPaymentAddress(input: EncryptPaymentAddressInput): ResultAsync<string, OrdersError>;
+interface DecryptPaymentAddressInput {
+    readonly encrypted: string;
+    readonly recipientIdentity: RelayIdentity;
+}
+/**
+ * Decrypts a ciphertext produced by `encryptPaymentAddress` using the recipient
+ * relay identity's private key. Returns the plaintext payment address.
+ */
+declare function decryptPaymentAddress(input: DecryptPaymentAddressInput): ResultAsync<string, OrdersError>;
+
+export { type ApproveUsdcParams, type CancelOrderParams, type ContractErrorCode, type DisputeStatus, type ExecuteBase, type FeeConfig, type GetFeeConfigParams, type GetOrderParams, type GetOrdersParams, type Order, type OrderEvent, type OrderStatus, type OrderType, type OrdersClient, type OrdersConfig, OrdersError, type OrdersErrorCode, type PaidBuyOrderAction, type PaidBuyOrderParams, type PlaceOrderParams, type PreparedTx, type PreparedTxMeta, type RaiseDisputeParams, type RelayIdentity, type RelayIdentityStore, type SetSellOrderUpiParams, type TxResult, type TxResultMeta, type WatchEventsParams, cipherParse, cipherStringify, contractErrorMessages, contractErrors, createInMemoryRelayStore, createLocalStorageRelayStore, createOrders, createRelayIdentity, decryptPaymentAddress, encryptPaymentAddress, getContractErrorMessage, hexContractErrors, parseContractError };