@bigmi/core 0.1.1 → 0.2.0-beta.0

package/src/utils/buildRequest.ts

@@ -0,0 +1,145 @@
+import { BaseError } from '../errors/base.js'
+import { HttpRequestError } from '../errors/request.js'
+import {
+  MethodNotSupportedRpcError,
+  RpcErrorCode,
+  UserRejectedRequestError,
+} from '../errors/rpc.js'
+import type { ErrorType } from '../errors/utils.js'
+import type {
+  BtcRpcRequestFn,
+  BtcRpcRequestOptions,
+  RpcSchema,
+} from '../types/request.js'
+import { stringToHex } from './converter.js'
+import { stringify } from './stringify.js'
+import { withDedupe } from './withDedupe.js'
+import { withRetry } from './withRetry.js'
+
+export type RequestErrorType = ErrorType
+
+export function buildRequest<request extends BtcRpcRequestFn<RpcSchema>>(
+  request: request,
+  options: BtcRpcRequestOptions = {}
+): BtcRpcRequestFn {
+  return async (args, overrideOptions = {}) => {
+    const {
+      dedupe = false,
+      methods,
+      retryDelay = 150,
+      retryCount = 3,
+      uid,
+    } = {
+      ...options,
+      ...overrideOptions,
+    }
+
+    const { method } = args
+    if (methods?.exclude?.includes(method)) {
+      throw new MethodNotSupportedRpcError(method)
+    }
+    if (methods?.include && !methods.include.includes(method)) {
+      throw new MethodNotSupportedRpcError(method)
+    }
+
+    const requestId = dedupe
+      ? stringToHex(`${uid}.${stringify(args)}`)
+      : undefined
+    return withDedupe(
+      () =>
+        withRetry(
+          async () => {
+            try {
+              return await request(args)
+            } catch (err_) {
+              const err = err_ as unknown as BaseError
+              switch (err.code) {
+                case RpcErrorCode.METHOD_NOT_SUPPORTED:
+                  throw new MethodNotSupportedRpcError(method)
+
+                case RpcErrorCode.USER_REJECTION:
+                  throw new UserRejectedRequestError(err.message)
+
+                // CAIP-25: User Rejected Error
+                // https://docs.walletconnect.com/2.0/specs/clients/sign/error-codes#rejected-caip-25
+                case 5000:
+                  throw new UserRejectedRequestError(err.message)
+
+                default:
+                  if (err_ instanceof BaseError) {
+                    throw err_
+                  }
+                  throw new BaseError('Unknown Error', { cause: err_ as Error })
+              }
+            }
+          },
+          {
+            delay: ({ count, error }) => {
+              // If we find a Retry-After header, let's retry after the given time.
+              if (error && error instanceof HttpRequestError) {
+                const retryAfter = error?.headers?.get('Retry-After')
+                if (retryAfter?.match(/\d/)) {
+                  return Number.parseInt(retryAfter) * 1000
+                }
+              }
+
+              // Otherwise, let's retry with an exponential backoff.
+              return ~~(1 << count) * retryDelay
+            },
+            retryCount,
+            shouldRetry: ({ error }) => shouldRetry(error),
+          }
+        ),
+      { enabled: dedupe, id: requestId }
+    )
+  }
+}
+
+/** @internal */
+export function shouldRetry(error: Error) {
+  if ('code' in error && typeof error.code === 'number') {
+    if (error.code === -1) {
+      return true // Unknown error
+    }
+    if (error.code === RpcErrorCode.INTERNAL_ERROR) {
+      return true
+    }
+    return false
+  }
+  if (error instanceof HttpRequestError && error.status) {
+    // Forbidden
+    if (error.status === 403) {
+      return true
+    }
+    // Request Timeout
+    if (error.status === 408) {
+      return true
+    }
+    // Request Entity Too Large
+    if (error.status === 413) {
+      return true
+    }
+    // Too Many Requests
+    if (error.status === 429) {
+      return true
+    }
+    // Internal Server Error
+    if (error.status === 500) {
+      return true
+    }
+    // Bad Gateway
+    if (error.status === 502) {
+      return true
+    }
+    // Service Unavailable
+    if (error.status === 503) {
+      return true
+    }
+    // Gateway Timeout
+    if (error.status === 504) {
+      return true
+    }
+    return false
+  }
+  return true
+}

package/src/utils/converter.ts

@@ -0,0 +1,25 @@
+export function hexToBase64(hex: string): string {
+  const raw = hex
+    .match(/.{1,2}/g)!
+    .map((byte: string) => String.fromCharCode(Number.parseInt(byte, 16)))
+    .join('')
+  return btoa(raw)
+}
+
+export function base64ToHex(base64: string): string {
+  const raw = atob(base64)
+  let hex = ''
+  for (let i = 0; i < raw.length; i++) {
+    const hexByte = raw.charCodeAt(i).toString(16)
+    hex += hexByte.length === 2 ? hexByte : `0${hexByte}`
+  }
+  return hex
+}
+
+export function stringToHex(value: string): string {
+  const hex = Array.from(value)
+    .map((char: string) => char.charCodeAt(0).toString(16).padStart(2, '0'))
+    .join('')
+
+  return `0x${hex}`
+}

package/src/utils/createBatchScheduler.ts

@@ -0,0 +1,116 @@
+import type { ErrorType } from '../errors/utils.js'
+import { withResolvers } from './withResolvers.js'
+
+type Resolved<returnType extends readonly unknown[] = any> = [
+  result: returnType[number],
+  results: returnType,
+]
+
+type SchedulerItem = {
+  args: unknown
+  resolve: PromiseWithResolvers<unknown>['resolve']
+  reject: PromiseWithResolvers<unknown>['reject']
+}
+
+type BatchResultsCompareFn<result = unknown> = (a: result, b: result) => number
+
+type CreateBatchSchedulerArguments<
+  parameters = unknown,
+  returnType extends readonly unknown[] = readonly unknown[],
+> = {
+  fn: (args: parameters[]) => Promise<returnType>
+  id: number | string
+  shouldSplitBatch?: ((args: parameters[]) => boolean) | undefined
+  wait?: number | undefined
+  sort?: BatchResultsCompareFn<returnType[number]> | undefined
+}
+
+type CreateBatchSchedulerReturnType<
+  parameters = unknown,
+  returnType extends readonly unknown[] = readonly unknown[],
+> = {
+  flush: () => void
+  schedule: parameters extends undefined
+    ? (args?: parameters | undefined) => Promise<Resolved<returnType>>
+    : (args: parameters) => Promise<Resolved<returnType>>
+}
+
+export type CreateBatchSchedulerErrorType = ErrorType
+
+const schedulerCache = /*#__PURE__*/ new Map<number | string, SchedulerItem[]>()
+
+/** @internal */
+export function createBatchScheduler<
+  parameters,
+  returnType extends readonly unknown[],
+>({
+  fn,
+  id,
+  shouldSplitBatch,
+  wait = 0,
+  sort,
+}: CreateBatchSchedulerArguments<
+  parameters,
+  returnType
+>): CreateBatchSchedulerReturnType<parameters, returnType> {
+  const exec = async () => {
+    const scheduler = getScheduler()
+    flush()
+
+    const args = scheduler.map(({ args }) => args)
+
+    if (args.length === 0) {
+      return
+    }
+
+    fn(args as parameters[])
+      .then((data) => {
+        if (sort && Array.isArray(data)) {
+          data.sort(sort)
+        }
+        for (let i = 0; i < scheduler.length; i++) {
+          const { resolve } = scheduler[i]
+          resolve?.([data[i], data])
+        }
+      })
+      .catch((err) => {
+        for (let i = 0; i < scheduler.length; i++) {
+          const { reject } = scheduler[i]
+          reject?.(err)
+        }
+      })
+  }
+
+  const flush = () => schedulerCache.delete(id)
+
+  const getBatchedArgs = () =>
+    getScheduler().map(({ args }) => args) as parameters[]
+
+  const getScheduler = () => schedulerCache.get(id) || []
+
+  const setScheduler = (item: SchedulerItem) =>
+    schedulerCache.set(id, [...getScheduler(), item])
+
+  return {
+    flush,
+    async schedule(args: parameters) {
+      const { promise, resolve, reject } = withResolvers()
+
+      const split = shouldSplitBatch?.([...getBatchedArgs(), args])
+
+      if (split) {
+        exec()
+      }
+
+      const hasActiveScheduler = getScheduler().length > 0
+      if (hasActiveScheduler) {
+        setScheduler({ args, resolve, reject })
+        return promise
+      }
+
+      setScheduler({ args, resolve, reject })
+      setTimeout(exec, wait)
+      return promise
+    },
+  } as unknown as CreateBatchSchedulerReturnType<parameters, returnType>
+}

package/src/utils/deepEqual.ts

@@ -0,0 +1,62 @@
+/** Forked from https://github.com/epoberezkin/fast-deep-equal */
+
+export function deepEqual(a: any, b: any) {
+  if (a === b) {
+    return true
+  }
+
+  if (a && b && typeof a === 'object' && typeof b === 'object') {
+    if (a.constructor !== b.constructor) {
+      return false
+    }
+
+    let length: number
+    let i: number
+
+    if (Array.isArray(a) && Array.isArray(b)) {
+      length = a.length
+      if (length !== b.length) {
+        return false
+      }
+      for (i = length; i-- !== 0; ) {
+        if (!deepEqual(a[i], b[i])) {
+          return false
+        }
+      }
+      return true
+    }
+
+    if (a.valueOf !== Object.prototype.valueOf) {
+      return a.valueOf() === b.valueOf()
+    }
+    if (a.toString !== Object.prototype.toString) {
+      return a.toString() === b.toString()
+    }
+
+    const keys = Object.keys(a)
+    length = keys.length
+    if (length !== Object.keys(b).length) {
+      return false
+    }
+
+    for (i = length; i-- !== 0; ) {
+      if (!Object.prototype.hasOwnProperty.call(b, keys[i]!)) {
+        return false
+      }
+    }
+
+    for (i = length; i-- !== 0; ) {
+      const key = keys[i]
+
+      if (key && !deepEqual(a[key], b[key])) {
+        return false
+      }
+    }
+
+    return true
+  }
+
+  // true if both NaN, false otherwise
+  // biome-ignore lint/suspicious/noSelfCompare: <explanation>
+  return a !== a && b !== b
+}

package/src/utils/getAction.ts

@@ -0,0 +1,45 @@
+import type { PublicActions } from '../clients/decorators/public.js'
+import type { WalletActions } from '../clients/decorators/wallet.js'
+import type { Transport } from '../factories/createTransport.js'
+import type { UTXOSchema } from '../transports/types.js'
+import type { Client } from '../types/client.js'
+
+import type { Account } from '../types/account.js'
+import type { Chain } from '../types/chain.js'
+
+/**
+ * Retrieves and returns an action from the client (if exists), and falls
+ * back to the tree-shakable action.
+ *
+ * Useful for extracting overridden actions from a client (ie. if a consumer
+ * wants to override the `sendTransaction` implementation).
+ */
+export function getAction<
+  transport extends Transport,
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+  rpcSchema extends UTXOSchema | undefined,
+  extended extends { [key: string]: unknown },
+  client extends Client<transport, chain, account, rpcSchema, extended>,
+  parameters,
+  returnType,
+>(
+  client: client,
+  actionFn: (_: any, parameters: parameters) => returnType,
+  // Some minifiers drop `Function.prototype.name`, or replace it with short letters,
+  // meaning that `actionFn.name` will not always work. For that case, the consumer
+  // needs to pass the name explicitly.
+  name: keyof PublicActions | keyof WalletActions | (string & {})
+): (parameters: parameters) => returnType {
+  const action_implicit = client[actionFn.name]
+  if (typeof action_implicit === 'function') {
+    return action_implicit as (params: parameters) => returnType
+  }
+
+  const action_explicit = client[name]
+  if (typeof action_explicit === 'function') {
+    return action_explicit as (params: parameters) => returnType
+  }
+
+  return (params) => actionFn(client, params)
+}

package/src/utils/getUTXOAddress.ts

@@ -1,6 +1,7 @@
 import { sha256 } from '@noble/hashes/sha256'
 import { type Decoded, bech32, bech32m } from 'bech32'
 import bs58 from 'bs58'
+import type { Address } from '../types/address.ts'
 
 export enum UTXONetwork {
   Mainnet = 'mainnet',
@@ -19,7 +20,7 @@ export enum UTXOAddressType {
 export type UTXOAddress = {
   bech32: boolean
   network: UTXONetwork
-  address: string
+  address: Address
   type: UTXOAddressType
 }
 
@@ -44,7 +45,7 @@ const addressTypes: {
   },
 }
 
-const parseBech32 = (address: string): UTXOAddress => {
+const parseBech32 = (address: Address): UTXOAddress => {
   let decoded: Decoded
 
   try {
@@ -97,7 +98,7 @@ const parseBech32 = (address: string): UTXOAddress => {
   }
 }
 
-export const getUTXOAddress = (address: string): UTXOAddress => {
+export const getUTXOAddress = (address: Address): UTXOAddress => {
   let decoded: Uint8Array
   const prefix = address.substring(0, 2).toLowerCase()
 

package/src/utils/isUTXOAddress.ts

@@ -1,3 +1,4 @@
+import type { Address } from '../types/address.js'
 import { type UTXONetwork, getUTXOAddress } from './getUTXOAddress.js'
 
 export const isUTXOAddress = (
@@ -5,7 +6,7 @@ export const isUTXOAddress = (
   network?: UTXONetwork
 ): boolean => {
   try {
-    const utxoAddress = getUTXOAddress(address)
+    const utxoAddress = getUTXOAddress(address as Address)
 
     if (network) {
       return network === utxoAddress.network

package/src/utils/lru.ts

@@ -0,0 +1,35 @@
+/**
+ * Map with a LRU (Least recently used) policy.
+ *
+ * @link https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU
+ */
+export class LruMap<value = unknown> extends Map<string, value> {
+  maxSize: number
+
+  constructor(size: number) {
+    super()
+    this.maxSize = size
+  }
+
+  override get(key: string) {
+    const value = super.get(key)
+
+    if (super.has(key) && value !== undefined) {
+      this.delete(key)
+      super.set(key, value)
+    }
+
+    return value
+  }
+
+  override set(key: string, value: value) {
+    super.set(key, value)
+    if (this.maxSize && this.size > this.maxSize) {
+      const firstKey = this.keys().next().value
+      if (firstKey) {
+        this.delete(firstKey)
+      }
+    }
+    return this
+  }
+}

package/src/utils/observe.ts

@@ -1,4 +1,4 @@
-import type { MaybePromise } from 'viem'
+import type { MaybePromise } from '../types/utils.js'
 
 type Callback = ((...args: any[]) => any) | undefined
 type Callbacks = Record<string, Callback>

package/src/utils/parseAccount.ts

@@ -0,0 +1,14 @@
+import type { ErrorType } from '../errors/utils.js'
+import type { Account } from '../types/account.js'
+import type { Address } from '../types/address.js'
+
+export type ParseAccountErrorType = ErrorType
+
+export function parseAccount<accountOrAddress extends Address | Account>(
+  account: accountOrAddress
+): accountOrAddress extends Address ? Account : accountOrAddress {
+  if (typeof account === 'string') {
+    return { address: account, type: 'json-rpc' } as any
+  }
+  return account as any
+}

package/src/utils/stringify.ts

@@ -0,0 +1,13 @@
+import type { ErrorType } from '../errors/utils.js'
+
+export type StringifyErrorType = ErrorType
+
+export const stringify: typeof JSON.stringify = (value, replacer, space) =>
+  JSON.stringify(
+    value,
+    (key, value_) => {
+      const value = typeof value_ === 'bigint' ? value_.toString() : value_
+      return typeof replacer === 'function' ? replacer(key, value) : value
+    },
+    space
+  )

package/src/utils/uid.ts

@@ -0,0 +1,14 @@
+const size = 256
+let index = size
+let buffer: string
+
+export function uid(length = 11) {
+  if (!buffer || index + length > size * 2) {
+    buffer = ''
+    index = 0
+    for (let i = 0; i < size; i++) {
+      buffer += ((256 + Math.random() * 256) | 0).toString(16).substring(1)
+    }
+  }
+  return buffer.substring(index, index++ + length)
+}

package/src/utils/wait.ts

@@ -0,0 +1,3 @@
+export async function wait(time: number) {
+  return new Promise((res) => setTimeout(res, time))
+}

package/src/utils/withDedupe.ts

@@ -0,0 +1,25 @@
+import { LruMap } from './lru.js'
+
+/** @internal */
+export const promiseCache = /*#__PURE__*/ new LruMap<Promise<any>>(8192)
+
+type WithDedupeOptions = {
+  enabled?: boolean | undefined
+  id?: string | undefined
+}
+
+/** Deduplicates in-flight promises. */
+export function withDedupe<data>(
+  fn: () => Promise<data>,
+  { enabled = true, id }: WithDedupeOptions
+): Promise<data> {
+  if (!enabled || !id) {
+    return fn()
+  }
+  if (promiseCache.get(id)) {
+    return promiseCache.get(id)!
+  }
+  const promise = fn().finally(() => promiseCache.delete(id))
+  promiseCache.set(id, promise)
+  return promise
+}

package/src/utils/withResolvers.ts

@@ -0,0 +1,19 @@
+/** @internal */
+export type PromiseWithResolvers<type> = {
+  promise: Promise<type>
+  resolve: (value: type | PromiseLike<type>) => void
+  reject: (reason?: unknown) => void
+}
+
+/** @internal */
+export function withResolvers<type>(): PromiseWithResolvers<type> {
+  let resolve: PromiseWithResolvers<type>['resolve'] = () => undefined
+  let reject: PromiseWithResolvers<type>['reject'] = () => undefined
+
+  const promise = new Promise<type>((resolve_, reject_) => {
+    resolve = resolve_
+    reject = reject_
+  })
+
+  return { promise, resolve, reject }
+}

package/src/utils/withRetry.ts

@@ -0,0 +1,60 @@
+import type { ErrorType } from '../errors/utils.js'
+import { wait } from './wait.js'
+
+export type WithRetryParameters = {
+  // The delay (in ms) between retries.
+  delay?:
+    | ((config: { count: number; error: Error }) => number)
+    | number
+    | undefined
+  // The max number of times to retry.
+  retryCount?: number | undefined
+  // Whether or not to retry when an error is thrown.
+  shouldRetry?:
+    | (({
+        count,
+        error,
+      }: {
+        count: number
+        error: Error
+      }) => Promise<boolean> | boolean)
+    | undefined
+}
+
+export type WithRetryErrorType = ErrorType
+
+export function withRetry<data>(
+  fn: () => Promise<data>,
+  {
+    delay: delay_ = 100,
+    retryCount = 2,
+    shouldRetry = () => true,
+  }: WithRetryParameters = {}
+) {
+  return new Promise<data>((resolve, reject) => {
+    const attemptRetry = async ({ count = 0 } = {}) => {
+      const retry = async ({ error }: { error: Error }) => {
+        const delay =
+          typeof delay_ === 'function' ? delay_({ count, error }) : delay_
+        if (delay) {
+          await wait(delay)
+        }
+        attemptRetry({ count: count + 1 })
+      }
+
+      try {
+        const data = await fn()
+        resolve(data)
+      } catch (err) {
+        if (
+          count < retryCount &&
+          (await shouldRetry({ count, error: err as Error }))
+        ) {
+          return retry({ error: err as Error })
+        }
+        reject(err)
+      }
+    }
+    attemptRetry()
+  })
+}

package/src/utils/withTimeout.ts

@@ -0,0 +1,47 @@
+import type { ErrorType } from '../errors/utils.js'
+
+export type WithTimeoutErrorType = ErrorType
+
+export function withTimeout<data>(
+  fn: ({
+    signal,
+  }: { signal: AbortController['signal'] | null }) => Promise<data>,
+  {
+    errorInstance = new Error('timed out'),
+    timeout,
+    signal,
+  }: {
+    // The error instance to throw when the timeout is reached.
+    errorInstance?: Error | undefined
+    // The timeout (in ms).
+    timeout: number
+    // Whether or not the timeout should use an abort signal.
+    signal?: boolean | undefined
+  }
+): Promise<data> {
+  return new Promise((resolve, reject) => {
+    ;(async () => {
+      let timeoutId!: NodeJS.Timeout
+      try {
+        const controller = new AbortController()
+        if (timeout > 0) {
+          timeoutId = setTimeout(() => {
+            if (signal) {
+              controller.abort()
+            } else {
+              reject(errorInstance)
+            }
+          }, timeout) as NodeJS.Timeout // need to cast because bun globals.d.ts overrides @types/node
+        }
+        resolve(await fn({ signal: controller?.signal || null }))
+      } catch (err) {
+        if ((err as Error)?.name === 'AbortError') {
+          reject(errorInstance)
+        }
+        reject(err)
+      } finally {
+        clearTimeout(timeoutId)
+      }
+    })()
+  })
+}

package/src/version.ts

@@ -0,0 +1 @@
+export const version = '0.1.1'