@coin-voyage/shared 0.0.1 → 0.0.3

package/dist/utils/index.js

@@ -0,0 +1,4 @@
+export * from "./account";
+export * from "./browser";
+export * from "./plurar";
+//# sourceMappingURL=index.js.map

package/dist/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAA;AACzB,cAAc,WAAW,CAAA;AACzB,cAAc,UAAU,CAAA"}

package/dist/utils/plurar.d.ts

@@ -0,0 +1 @@
+export declare const withPlural: (totalQuantity: number, singular: string, plural: string) => string;

package/dist/utils/plurar.js

@@ -0,0 +1,7 @@
+export const withPlural = (totalQuantity, singular, plural) => {
+    if (totalQuantity == 1)
+        return `${totalQuantity} ${singular}`;
+    else
+        return `${totalQuantity} ${plural}`;
+};
+//# sourceMappingURL=plurar.js.map

package/dist/utils/plurar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plurar.js","sourceRoot":"","sources":["../../src/utils/plurar.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,aAAqB,EAAE,QAAgB,EAAE,MAAc,EAAE,EAAE;IAClF,IAAI,aAAa,IAAI,CAAC;QAAE,OAAO,GAAG,aAAa,IAAI,QAAQ,EAAE,CAAC;;QACzD,OAAO,GAAG,aAAa,IAAI,MAAM,EAAE,CAAC;AAC3C,CAAC,CAAC"}

package/package.json

@@ -1,22 +1,22 @@
 {
   "name": "@coin-voyage/shared",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "private": false,
   "sideEffects": false,
   "exports": {
-    ".": "./src/index.ts",
-    "./*": [
-      "./src/*/index.ts",
-      "./src/*/index.tsx"
-    ]
+    "./api": "./dist/api/index.ts",
+    "./common": "./dist/common/index.ts",
+    "./hooks": "./dist/hooks/index.ts",
+    "./utils": "./dist/utils/index.ts"
   },
   "files": [
-    "src"
+    "dist"
   ],
   "typesVersions": {
     "*": {
       "*": [
-        "src/*/index.d.ts"
+        "dist/*",
+        "dist/*/index.d.ts"
       ]
     }
   },

package/src/api/config.ts

@@ -1,2 +0,0 @@
-export const API_URL = "https://dev-api.coinvoyage.io"
-// export const API_URL = "http://localhost:8000"

package/src/api/index.ts

@@ -1,3 +0,0 @@
-export * from "./config"
-export * from "./fetcher"
-export * from "./pay-order"

package/src/common/assert.ts

@@ -1,21 +0,0 @@
-import { debugJson } from "./debug"
-
-export function assert(condition: boolean, ...args: any[]): asserts condition {
-  if (!condition) {
-    throw new Error(
-      `Assertion failed: ${args.map((a) => debugJson(a)).join(", ")}`
-    )
-  }
-}
-
-export function assertNotNull<T>(
-  value: T | null | undefined,
-  ...args: any[]
-): T {
-  assert(value !== null && value !== undefined, ...args)
-  return value
-}
-
-export function assertEqual<T>(a: T, b: T, ...args: any[]): void {
-  assert(a === b, ...args)
-}

package/src/common/chainExplorer.ts

@@ -1,27 +0,0 @@
-import { ChainId } from "./chains"
-
-const chainExplorerUrls: Record<ChainId, string> = {
-  [ChainId.ETH]: "https://etherscan.io",
-  [ChainId.ARB]: "https://arbiscan.io",
-  [ChainId.BASE]: "https://basescan.org",
-  [ChainId.BLAST]: "https://blastexplorer.io",
-  [ChainId.OP]: "https://optimistic.etherscan.io",
-  [ChainId.POL]: "https://polygonscan.com",
-  [ChainId.AVAX]: "https://snowtrace.io",
-  [ChainId.SEPOLIA]: "https://sepolia.etherscan.io",
-  [ChainId.SEPOLIA_BASE]: "https://sepolia.basescan.org",
-  [ChainId.SEPOLIA_ARB]: "https://sepolia.arbiscan.io",
-  [ChainId.SEPOLIA_OP]: "https://sepolia-optimism.etherscan.io",
-  [ChainId.BSC]: "https://bscscan.com",
-  [ChainId.ZKSYNC]: "https://explorer.zksync.io",
-  [ChainId.FTM]: "https://ftmscan.com",
-  [ChainId.SOL]: "https://solscan.io",
-  [ChainId.SUI]: "https://suiscan.xyz",
-  [ChainId.TRX]: "https://tronscan.org",
-  [ChainId.BTC]: "https://mempool.space",
-}
-
-export function getChainExplorerTxUrl(chainId: ChainId, txHash?: string) {
-  const explorer = chainExplorerUrls[chainId]
-  return `${explorer}/tx/${txHash}`
-}

package/src/common/chains.ts

@@ -1,130 +0,0 @@
-import * as chains from "viem/chains"
-
-export enum ChainType {
-  EVM = "EVM",
-  // Solana virtual machine
-  SOL = "SOL",
-  SUI = "SUI",
-  TRON = "TRON",
-  // Unspent transaction output (e.g. Bitcoin, Litecoin, Dogecoin)
-  UTXO = "UTXO",
-}
-
-export function getChainTypeName(chainType?: ChainType): string {
-  switch (chainType) {
-    case ChainType.EVM:
-      return "Ethereum"
-    case ChainType.SOL:
-      return "Solana"
-    case ChainType.SUI:
-      return "Sui"
-    case ChainType.TRON:
-      return "Tron"
-    case ChainType.UTXO:
-      return "Bitcoin"
-    default:
-      return ""
-  }
-}
-
-export enum ChainId {
-  ETH = 1,
-  OP = 10,
-  BSC = 56,
-  POL = 137,
-  FTM = 250,
-  ZKSYNC = 324,
-  BASE = 8453,
-  ARB = 42161,
-  AVAX = 43114,
-  BLAST = 81457,
-
-  // testnet
-  SEPOLIA = 11155111,
-  SEPOLIA_BASE = 84532,
-  SEPOLIA_ARB = 421614,
-  SEPOLIA_OP = 11155420,
-
-  // UTXO (IDs are made up)
-  BTC = 20000000000001,
-  // BCH = 20000000000002,
-  // LTC = 20000000000003,
-  // DGE = 20000000000004,
-
-  // None-EVM (IDs are made up)
-  SOL = 30000000000001,
-  SUI = 30000000000002,
-  TRX = 30000000000003,
-  // XRPL = 30000000000004,
-}
-
-export function getChainTypeByChainId(chainId?: ChainId): ChainType {
-  switch (chainId) {
-    case ChainId.ETH:
-    case ChainId.OP:
-    case ChainId.BSC:
-    case ChainId.POL:
-    case ChainId.FTM:
-    case ChainId.ZKSYNC:
-    case ChainId.BASE:
-    case ChainId.ARB:
-    case ChainId.AVAX:
-    case ChainId.BLAST:
-      return ChainType.EVM
-    case ChainId.SOL:
-      return ChainType.SOL
-    case ChainId.SUI:
-      return ChainType.SUI
-    case ChainId.TRX:
-      return ChainType.TRON
-    case ChainId.BTC:
-      return ChainType.UTXO
-    default:
-      return ChainType.EVM
-  }
-}
-
-export function isTestnetChain(chainId: number): boolean {
-  return Boolean(
-    Object.values(chains).find((chain) => chain.id === chainId)?.testnet
-  )
-}
-
-export function getChainName(chainId?: ChainId): string | undefined {
-  if (!chainId) {
-    return
-  }
-
-  switch (chainId) {
-    case ChainId.ETH:
-      return "Ethereum"
-    case ChainId.OP:
-      return "Optimism"
-    case ChainId.BSC:
-      return "Binance Smart Chain"
-    case ChainId.POL:
-      return "Polygon"
-    case ChainId.FTM:
-      return "Fantom"
-    case ChainId.ZKSYNC:
-      return "zkSync"
-    case ChainId.BASE:
-      return "Base"
-    case ChainId.ARB:
-      return "Arbitrum"
-    case ChainId.AVAX:
-      return "Avalanche"
-    case ChainId.BLAST:
-      return "Blast"
-    case ChainId.SOL:
-      return "Solana"
-    case ChainId.SUI:
-      return "Sui"
-    case ChainId.TRX:
-      return "Tron"
-    case ChainId.BTC:
-      return "Bitcoin"
-    default:
-      return
-  }
-}

package/src/common/currencies.ts

@@ -1,42 +0,0 @@
-export interface CurrencyExchangeRate {
-  name: string
-  symbol: string
-  currency: string
-  decimals: number
-  rateUSD: number
-}
-
-export const currencyRateUSD: CurrencyExchangeRate = {
-  name: "US Dollar",
-  symbol: "$",
-  currency: "USD",
-  decimals: 2,
-  rateUSD: 1,
-}
-
-const data: [string, string, string, number][] = [
-  ["Euro", "€", "EUR", 2],
-  ["Argentine Peso", "ARS", "ARS", 0],
-  ["Bolivian Boliviano", "$Bs", "BOB", 0],
-  ["Turkish Lira", "₺", "TRY", 0],
-  ["New Taiwan Dollar", "NT$", "TWD", 0],
-  ["Ukrainian Hryvnia", "₴", "UAH", 0],
-  ["Naira", "₦", "NGN", 0],
-  ["Swiss Franc", "₣", "CHF", 2],
-  ["Japanese Yen", "¥", "JPY", 0],
-  ["Korean Won", "₩", "KRW", 0],
-  ["Yuan", "¥", "CNY", 0],
-  ["Pound", "£", "GBP", 2],
-  ["Canadian Dollar", "C$", "CAD", 2],
-  ["Australian Dollar", "A$", "AUD", 2],
-  ["Singapore Dollar", "S$", "SGD", 2],
-]
-
-export const nonUsdCurrencies = data.map(
-  ([name, symbol, currency, decimals]) => ({
-    name,
-    symbol,
-    currency,
-    decimals,
-  })
-)

package/src/common/debug.ts

@@ -1,11 +0,0 @@
-// Return compact JSON, 1000 chars max. Never throws.
-export function debugJson(obj: any) {
-  try {
-    const serialized = JSON.stringify(obj, (_, value) =>
-      typeof value === "bigint" ? value.toString() : value
-    )
-    return serialized.slice(0, 1000)
-  } catch (e: any) {
-    return `<JSON error: ${e.message}>`
-  }
-}

package/src/common/format.ts

@@ -1,3 +0,0 @@
-export function capitalize(str: string) {
-  return str.charAt(0).toUpperCase() + str.slice(1)
-}

package/src/common/i18n/index.ts

@@ -1,18 +0,0 @@
-import { en } from "./languages/en"
-import { es } from "./languages/es"
-
-export interface Locale {
-  languageCode?: string
-}
-
-export type I18NTranslation = typeof en
-
-// Return i18n translation based on locale
-export const i18n = (locale: Locale | undefined): I18NTranslation => {
-  switch (locale?.languageCode) {
-    case "es":
-      return es
-    default:
-      return en
-  }
-}

package/src/common/i18n/languages/en.ts

@@ -1,38 +0,0 @@
-export const en = {
-  // format.ts
-  format: {
-    fee: () => "Fee:",
-  },
-
-  // op.ts
-  op: {
-    acceptedInbound: (
-      readableAmount: string,
-      otherCoinSymbol: string,
-      homeCoinSymbol: string,
-      chain?: string
-    ) =>
-      `Accepted ${readableAmount} ${otherCoinSymbol}${
-        chain ? ` on ${chain}` : ""
-      } as ${homeCoinSymbol}`,
-    sentOutbound: (
-      readableAmount: string,
-      coinSymbol: string,
-      chain?: string
-    ) => `Sent ${readableAmount} ${coinSymbol}${chain ? ` on ${chain}` : ""}`,
-  },
-
-  // time.ts
-  time: {
-    soon: () => "soon",
-    now: (long?: boolean) => `${long ? "just now" : "now"}`,
-    minutesAgo: (minutes: number, long?: boolean) =>
-      `${minutes}m ${long ? "ago" : ""}`,
-    hoursAgo: (hours: number, long?: boolean) =>
-      `${hours}h ${long ? "ago" : ""}`,
-    daysAgo: (days: number, long?: boolean) => `${days}d ${long ? "ago" : ""}`,
-    inDays: (days: number, long?: boolean) => `${long ? "in" : ""} ${days}d`,
-  },
-}
-
-export type LanguageDefinition = typeof en

package/src/common/i18n/languages/es.ts

@@ -1,38 +0,0 @@
-import type { LanguageDefinition } from "./en"
-export const es: LanguageDefinition = {
-  // format.ts
-  format: {
-    fee: () => "Tasas:",
-  },
-
-  // op.ts
-  op: {
-    acceptedInbound: (
-      readableAmount: string,
-      otherCoinSymbol: string,
-      homeCoinSymbol: string,
-      chain?: string
-    ) =>
-      `Aceptado ${readableAmount} ${otherCoinSymbol}${
-        chain ? ` en ${chain}` : ""
-      } como ${homeCoinSymbol}`,
-    sentOutbound: (
-      readableAmount: string,
-      coinSymbol: string,
-      chain?: string
-    ) =>
-      `Envidado ${readableAmount} ${coinSymbol}${chain ? ` en ${chain}` : ""}`,
-  },
-
-  // time.ts
-  time: {
-    soon: () => "pronto",
-    now: () => "ahora",
-    minutesAgo: (minutes: number, long?: boolean) =>
-      `${long ? "hace" : ""} ${minutes}m`,
-    hoursAgo: (hours: number, long?: boolean) =>
-      `${long ? "hace" : ""} ${hours}h`,
-    daysAgo: (days: number, long?: boolean) => `${long ? "hace" : ""} ${days}d`,
-    inDays: (days: number, long?: boolean) => `${long ? "en" : ""} ${days}d`,
-  },
-}

package/src/common/index.ts

@@ -1,12 +0,0 @@
-export * from "./assert"
-export * from "./chainExplorer"
-export * from "./chains"
-export * from "./currencies"
-export * from "./organization"
-export * from "./pay"
-export * from "./debug"
-export * from "./format"
-export * from "./model"
-export * from "./retryBackoff"
-export * from "./time"
-export * from "./i18n"

package/src/common/model.ts

@@ -1,43 +0,0 @@
-import type { Address } from "viem"
-import { z } from "zod"
-import { ChainId } from "./chains"
-
-export const zSolanaPublicKey = z.string().regex(/^[1-9A-HJ-NP-Za-km-z]+$/)
-
-export type SolanaPublicKey = z.infer<typeof zSolanaPublicKey>
-
-export interface Currency extends CurrencyBase {
-  id?: string
-  name: string
-  ticker: string
-  decimals: number
-  image_uri?: string
-  price_usd?: number
-}
-
-export interface CurrencyBase {
-  chain_id: ChainId
-  address: string | null
-}
-
-export const zAddress = z
-  .string()
-  .regex(/^0x[0-9a-f]{40}$/i)
-  .refine((s): s is Address => true)
-
-export const zBigIntStr = z
-  .string()
-  .regex(/^[0-9]+$/i)
-  .refine((s): s is BigIntStr => true)
-
-export type BigIntStr = `${bigint}`
-
-export type PlatformType = "ios" | "android" | "other"
-
-export function dateToUnix(d: Date): number {
-  return Math.floor(d.getTime() / 1000)
-}
-
-export function unixToDate(unix: number): Date {
-  return new Date(unix * 1000)
-}

package/src/common/pay.ts

@@ -1,194 +0,0 @@
-import { Address, Hex, zeroAddress } from "viem"
-import z from "zod"
-import { Currency, zAddress, zBigIntStr } from "./model"
-
-
-export enum PayOrderMode {
-  SALE = "SALE", // product or item sale, value out can only be adjusted by the merchant 
-  DEPOSIT = "DEPOSIT", // deposit into user account, let the user specify the value out
-}
-
-export const zBridgeTokenOutOptions = z.array(
-  z.object({
-    token: zAddress,
-    amount: zBigIntStr.transform((a) => BigInt(a)),
-  })
-)
-
-export type BridgeTokenOutOptions = z.infer<typeof zBridgeTokenOutOptions>
-
-// NOTE: be careful to modify this type only in backward-compatible ways.
-//       Add OPTIONAL fields, etc. Anything else requires a migration.
-export const zPayOrderMetadata = z.object({
-  items: z
-    .array(
-      z.object({
-        name: z.string(),
-        description: z.string().optional(),
-        image: z.string().optional(),
-        quantity: z.number().int().optional(),
-        unit_price: z.number().optional(),
-        currency: z.string().optional(),
-      })
-    )
-    .describe("Details about what's being ordered, donated, deposited, etc."),
-})
-
-// also validate not both destination_value_usd and destination_amount are present
-export const zDepositPayOrder = z.object({
-  metadata: zPayOrderMetadata.optional(),
-  destination_value_usd: z.number().optional()
-    .refine((val) => val === undefined || Number(val) > 0, {
-      message: "destination_value_usd must be greater than zero if defined",
-    }),
-  destination_currency: z.object({
-    chain_id: z.number(),
-    address: z.string().nullable(),
-  }),
-  destination_amount: z.string().optional()
-    .refine((val) => val === undefined || Number(val) > 0, {
-      message: "destination_amount must be greater than zero if defined",
-    }),
-  receiving_address: z.string().min(1),
-}).refine(
-  (data) =>
-    !(data.destination_value_usd && data.destination_amount), // Ensure not both are present
-  {
-    message: "Only one of destination_value_usd or destination_amount should be present.",
-    path: ["destination_value_usd", "destination_amount"],
-  }
-);
-
-export type PayOrderMetadata = z.infer<typeof zPayOrderMetadata>
-
-export enum PayOrderStatus {
-  PENDING = "PENDING",
-  FAILED = "FAILED",
-  AWAITING_PAYMENT = "AWAITING_PAYMENT",
-  AWAITING_CONFIRMATION = "AWAITING_CONFIRMATION",
-  EXECUTING_ORDER = "EXECUTING_ORDER",
-  COMPLETED = "COMPLETED",
-  EXPIRED = "EXPIRED",
-  REFUNDED = "REFUNDED",
-}
-
-export type PayOrder = {
-  id: string
-
-  mode: PayOrderMode.SALE | PayOrderMode.DEPOSIT
-  status: PayOrderStatus
-  metadata?: PayOrderMetadata
-  expires_at?: Date
-
-  source_currency?: Currency
-  source_amount?: CurrencyAmount
-  deposit_tx_hash?: string
-
-  destination_currency?: Currency
-  destination_amount?: CurrencyAmount
-  receiving_tx_hash?: string
-
-  receiving_address?: string
-  refund_address?: string
-  deposit_address?: string
-
-  refund_tx_hash?: string
-}
-
-export interface CurrencyWithAmount extends Currency {
-  currency_amount: CurrencyAmount
-}
-
-export interface CurrencyWithBalance extends CurrencyWithAmount {
-  balance?: CurrencyAmount
-}
-
-export interface CurrencyAmount {
-  ui_amount: number
-  raw_amount: bigint
-  value_usd: number
-}
-
-export type OnChainCall = {
-  to: Address
-  data: Hex
-  value: bigint
-}
-
-export const emptyOnChainCall: OnChainCall = {
-  to: zeroAddress,
-  data: "0x",
-  value: BigInt(0),
-}
-
-export const zUUID = z.string().uuid()
-
-export type UUID = z.infer<typeof zUUID>
-
-export type PaymentCreationErrorEvent = {
-  type: "payment_creation_error"
-  errorMessage: string
-}
-
-export type PaymentStartedEvent = {
-  type: "payment_started"
-  paymentId: string
-  chainId: number
-  txHash: Hex | string | null
-}
-
-export type PaymentCompletedEvent = {
-  type: "payment_completed"
-  paymentId: UUID
-  chainId: number
-  txHash: Hex | string
-}
-
-export type PaymentBouncedEvent = {
-  type: "payment_bounced"
-  paymentId: UUID
-  chainId: number
-  txHash: Hex | string
-}
-
-export type PayEvent =
-  | PaymentStartedEvent
-  | PaymentCompletedEvent
-  | PaymentBouncedEvent
-
-export interface WebhookEndpoint {
-  id: string
-  organization_id: string
-  active: boolean
-  url: string
-  webhook_secret: string
-  subscription_events: WebhookEventStatus[]
-  created_at: Date
-}
-
-export enum WebhookEventStatus {
-  ORDER_CREATED = "ORDER_CREATED",
-  ORDER_AWAITING_PAYMENT = "ORDER_AWAITING_PAYMENT",
-  ORDER_CONFIRMING = "ORDER_CONFIRMING",
-  ORDER_EXECUTING = "ORDER_EXECUTING",
-  ORDER_COMPLETED = "ORDER_COMPLETED",
-  ORDER_ERROR = "ORDER_ERROR",
-  ORDER_REFUNDED = "ORDER_REFUNDED"
-}
-
-export interface WebhookEvent {
-  id: UUID
-  endpoint: WebhookEndpoint
-  body: PayEvent
-  status: WebhookEventStatus
-  //deliveries: WebhookDelivery[]
-  createdAt: Date
-}
-
-// export interface WebhookDelivery {
-//   id: UUID
-//   eventId: UUID
-//   httpStatus: number | null
-//   body: string | null
-//   createdAt: Date
-// }

package/src/common/retryBackoff.ts

@@ -1,24 +0,0 @@
-// Retries a function up to a maximum number of times, with exponential backoff.
-// Current settings, max total wait time is ~10 seconds.
-export async function retryBackoff<T>(
-  name: string,
-  fn: () => Promise<T>,
-  maxRetries = 5,
-  backoffFn: (i: number) => number = (i) => Math.min(2000, 250 * 2 ** i)
-): Promise<T> {
-  for (let i = 1; ; i++) {
-    try {
-      return await fn()
-    } catch (e) {
-      if (i <= maxRetries) {
-        const sleepMs = backoffFn(i)
-        await new Promise((r) => setTimeout(r, sleepMs))
-      } else {
-        console.warn(`[RETRY] ${name} QUITTING after try ${i}, error: ${e}`)
-        break
-      }
-    }
-  }
-  // TODO: add performance logging
-  throw new Error(`too many retries: ${name}`)
-}