viem 0.0.0-main.20240103T193024 → 0.0.0-main.20240103T193934

package/types/contract.ts

@@ -1,21 +1,19 @@
-import type {
-  Abi,
-  AbiConstructor,
-  AbiError,
-  AbiEvent,
-  AbiFunction,
-  AbiParameter,
-  AbiParameterToPrimitiveType,
-  AbiParametersToPrimitiveTypes,
-  AbiStateMutability,
-  Address,
-  ExtractAbiError,
-  ExtractAbiErrorNames,
-  ExtractAbiEvent,
-  ExtractAbiEventNames,
-  ExtractAbiFunction,
-  ExtractAbiFunctionNames,
-  Narrow,
+import {
+  type Abi,
+  type AbiEvent,
+  type AbiFunction,
+  type AbiParameter,
+  type AbiParameterToPrimitiveType,
+  type AbiParametersToPrimitiveTypes,
+  type AbiStateMutability,
+  type Address,
+  type ExtractAbiError,
+  type ExtractAbiErrorNames,
+  type ExtractAbiEvent,
+  type ExtractAbiEventNames,
+  type ExtractAbiFunction,
+  type ExtractAbiFunctionNames,
+  type ResolvedRegister,
 } from 'abitype'
 
 import type { Hex, LogTopic } from './misc.js'
@@ -23,45 +21,281 @@ import type { TransactionRequest } from './transaction.js'
 import type {
   Filter,
   IsNarrowable,
+  IsUnion,
   MaybeRequired,
   NoUndefined,
   Prettify,
+  UnionToTuple,
 } from './utils.js'
 
-export type AbiItem = Abi[number]
+export type ContractFunctionName<
+  abi extends Abi | readonly unknown[] = Abi,
+  mutability extends AbiStateMutability = AbiStateMutability,
+> = ExtractAbiFunctionNames<
+  abi extends Abi ? abi : Abi,
+  mutability
+> extends infer functionName extends string
+  ? [functionName] extends [never]
+    ? string
+    : functionName
+  : string
 
-export type EventDefinition = `${string}(${string})`
+export type ContractErrorName<abi extends Abi | readonly unknown[] = Abi> =
+  ExtractAbiErrorNames<
+    abi extends Abi ? abi : Abi
+  > extends infer errorName extends string
+    ? [errorName] extends [never]
+      ? string
+      : errorName
+    : string
+
+export type ContractEventName<abi extends Abi | readonly unknown[] = Abi> =
+  ExtractAbiEventNames<
+    abi extends Abi ? abi : Abi
+  > extends infer eventName extends string
+    ? [eventName] extends [never]
+      ? string
+      : eventName
+    : string
+
+export type ContractFunctionArgs<
+  abi extends Abi | readonly unknown[] = Abi,
+  mutability extends AbiStateMutability = AbiStateMutability,
+  functionName extends ContractFunctionName<
+    abi,
+    mutability
+  > = ContractFunctionName<abi, mutability>,
+> = AbiParametersToPrimitiveTypes<
+  ExtractAbiFunction<
+    abi extends Abi ? abi : Abi,
+    functionName,
+    mutability
+  >['inputs'],
+  'inputs'
+> extends infer args
+  ? [args] extends [never]
+    ? readonly unknown[]
+    : args
+  : readonly unknown[]
+
+export type ContractConstructorArgs<
+  abi extends Abi | readonly unknown[] = Abi,
+> = AbiParametersToPrimitiveTypes<
+  Extract<
+    (abi extends Abi ? abi : Abi)[number],
+    { type: 'constructor' }
+  >['inputs'],
+  'inputs'
+> extends infer args
+  ? [args] extends [never]
+    ? readonly unknown[]
+    : args
+  : readonly unknown[]
+
+export type ContractErrorArgs<
+  abi extends Abi | readonly unknown[] = Abi,
+  errorName extends ContractErrorName<abi> = ContractErrorName<abi>,
+> = AbiParametersToPrimitiveTypes<
+  ExtractAbiError<abi extends Abi ? abi : Abi, errorName>['inputs'],
+  'inputs'
+> extends infer args
+  ? [args] extends [never]
+    ? readonly unknown[]
+    : args
+  : readonly unknown[]
+
+export type ContractEventArgs<
+  abi extends Abi | readonly unknown[] = Abi,
+  eventName extends ContractEventName<abi> = ContractEventName<abi>,
+> = AbiEventParametersToPrimitiveTypes<
+  ExtractAbiEvent<abi extends Abi ? abi : Abi, eventName>['inputs']
+> extends infer args
+  ? [args] extends [never]
+    ? readonly unknown[] | Record<string, unknown>
+    : args
+  : readonly unknown[] | Record<string, unknown>
+
+export type ContractEventArgsFromTopics<
+  abi extends Abi | readonly unknown[] = Abi,
+  eventName extends ContractEventName<abi> = ContractEventName<abi>,
+  strict extends boolean = true,
+> = AbiEventParametersToPrimitiveTypes<
+  ExtractAbiEvent<abi extends Abi ? abi : Abi, eventName>['inputs'],
+  { EnableUnion: false; IndexedOnly: false; Required: strict }
+> extends infer args
+  ? [args] extends [never]
+    ? readonly unknown[] | Record<string, unknown>
+    : args
+  : readonly unknown[] | Record<string, unknown>
+
+export type Widen<type> =
+  | ([unknown] extends [type] ? unknown : never)
+  | (type extends Function ? type : never)
+  | (type extends ResolvedRegister['BigIntType'] ? bigint : never)
+  | (type extends boolean ? boolean : never)
+  | (type extends ResolvedRegister['IntType'] ? number : never)
+  | (type extends string
+      ? type extends ResolvedRegister['AddressType']
+        ? ResolvedRegister['AddressType']
+        : type extends ResolvedRegister['BytesType']['inputs']
+          ? ResolvedRegister['BytesType']
+          : string
+      : never)
+  | (type extends readonly [] ? readonly [] : never)
+  | (type extends Record<string, unknown>
+      ? { [K in keyof type]: Widen<type[K]> }
+      : never)
+  | (type extends { length: number }
+      ? {
+          [K in keyof type]: Widen<type[K]>
+        } extends infer Val extends readonly unknown[]
+        ? readonly [...Val]
+        : never
+      : never)
 
-export type ContractFunctionConfig<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string = string,
-  TAbiStateMutability extends AbiStateMutability = AbiStateMutability,
+export type UnionWiden<type> = type extends any ? Widen<type> : never
+
+export type ExtractAbiFunctionForArgs<
+  abi extends Abi,
+  mutability extends AbiStateMutability,
+  functionName extends ContractFunctionName<abi, mutability>,
+  args extends ContractFunctionArgs<abi, mutability, functionName>,
+> = ExtractAbiFunction<
+  abi,
+  functionName,
+  mutability
+> extends infer abiFunction extends AbiFunction
+  ? IsUnion<abiFunction> extends true // narrow overloads using `args` by converting to tuple and filtering out overloads that don't match
+    ? UnionToTuple<abiFunction> extends infer abiFunctions extends
+        readonly AbiFunction[]
+      ? {
+          [k in keyof abiFunctions]: (
+            readonly [] extends args
+              ? readonly [] // fallback to `readonly []` if `args` has no value (e.g. `args` property not provided)
+              : args
+          ) extends AbiParametersToPrimitiveTypes<
+            abiFunctions[k]['inputs'],
+            'inputs'
+          >
+            ? abiFunctions[k]
+            : never
+        }[number] // convert back to union (removes `never` tuple entries: `['foo', never, 'bar'][number]` => `'foo' | 'bar'`)
+      : never
+    : abiFunction
+  : never
+
+export type ContractFunctionParameters<
+  abi extends Abi | readonly unknown[] = Abi,
+  mutability extends AbiStateMutability = AbiStateMutability,
+  functionName extends ContractFunctionName<
+    abi,
+    mutability
+  > = ContractFunctionName<abi, mutability>,
+  args extends ContractFunctionArgs<
+    abi,
+    mutability,
+    functionName
+  > = ContractFunctionArgs<abi, mutability, functionName>,
+  ///
+  allFunctionNames = ContractFunctionName<abi, mutability>,
+  allArgs = ContractFunctionArgs<abi, mutability, functionName>,
+  // when `args` is inferred to `readonly []` ("inputs": []) or `never` (`abi` declared as `Abi` or not inferrable), allow `args` to be optional.
+  // important that both branches return same structural type
 > = {
-  /** Contract ABI */
-  abi: Narrow<TAbi>
-  /** Contract address */
   address: Address
-  /** Function to invoke on the contract */
-  functionName: InferFunctionName<TAbi, TFunctionName, TAbiStateMutability>
-} & GetFunctionArgs<TAbi, TFunctionName>
-
-export type ContractFunctionResult<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string = string,
-  TAbiFunction extends AbiFunction & {
-    type: 'function'
-  } = TAbi extends Abi ? ExtractAbiFunction<TAbi, TFunctionName> : AbiFunction,
-  TArgs = AbiParametersToPrimitiveTypes<TAbiFunction['outputs']>,
-  FailedToParseArgs =
-    | ([TArgs] extends [never] ? true : false)
-    | (readonly unknown[] extends TArgs ? true : false),
-> = true extends FailedToParseArgs
-  ? unknown
-  : TArgs extends readonly []
-    ? void
-    : TArgs extends readonly [infer Arg]
-      ? Arg
-      : TArgs
+  abi: abi
+  functionName:
+    | allFunctionNames // show all options
+    | (functionName extends allFunctionNames ? functionName : never) // infer value
+  args?: (abi extends Abi ? UnionWiden<args> : never) | allArgs | undefined
+} & (readonly [] extends allArgs ? {} : { args: Widen<args> })
+
+export type ContractFunctionReturnType<
+  abi extends Abi | readonly unknown[] = Abi,
+  mutability extends AbiStateMutability = AbiStateMutability,
+  functionName extends ContractFunctionName<
+    abi,
+    mutability
+  > = ContractFunctionName<abi, mutability>,
+  args extends ContractFunctionArgs<
+    abi,
+    mutability,
+    functionName
+  > = ContractFunctionArgs<abi, mutability, functionName>,
+> = abi extends Abi
+  ? Abi extends abi
+    ? unknown
+    : AbiParametersToPrimitiveTypes<
+          ExtractAbiFunctionForArgs<
+            abi,
+            mutability,
+            functionName,
+            args
+          >['outputs']
+        > extends infer types
+      ? types extends readonly []
+        ? void
+        : types extends readonly [infer type]
+          ? type
+          : types
+      : never
+  : unknown
+
+export type AbiItem = Abi[number]
+
+export type ExtractAbiItemNames<abi extends Abi> = Extract<
+  abi[number],
+  { name: string }
+>['name']
+
+export type ExtractAbiItem<
+  abi extends Abi,
+  name extends ExtractAbiItemNames<abi>,
+> = Extract<abi[number], { name: name }>
+
+export type AbiItemName<abi extends Abi | readonly unknown[] = Abi> =
+  abi extends Abi ? ExtractAbiItemNames<abi> : string
+
+export type AbiItemArgs<
+  abi extends Abi | readonly unknown[] = Abi,
+  name extends AbiItemName<abi> = AbiItemName<abi>,
+> = AbiParametersToPrimitiveTypes<
+  ExtractAbiItem<abi extends Abi ? abi : Abi, name>['inputs'],
+  'inputs'
+> extends infer args
+  ? [args] extends [never]
+    ? readonly unknown[]
+    : args
+  : readonly unknown[]
+
+export type ExtractAbiItemForArgs<
+  abi extends Abi,
+  name extends AbiItemName<abi>,
+  args extends AbiItemArgs<abi, name>,
+> = ExtractAbiItem<abi, name> extends infer abiItem extends AbiItem & {
+  inputs: readonly AbiParameter[]
+}
+  ? IsUnion<abiItem> extends true // narrow overloads using `args` by converting to tuple and filtering out overloads that don't match
+    ? UnionToTuple<abiItem> extends infer abiItems extends readonly (AbiItem & {
+        inputs: readonly AbiParameter[]
+      })[]
+      ? {
+          [k in keyof abiItems]: (
+            readonly [] extends args
+              ? readonly [] // fallback to `readonly []` if `args` has no value (e.g. `args` property not provided)
+              : args
+          ) extends AbiParametersToPrimitiveTypes<
+            abiItems[k]['inputs'],
+            'inputs'
+          >
+            ? abiItems[k]
+            : never
+        }[number] // convert back to union (removes `never` tuple entries: `['foo', never, 'bar'][number]` => `'foo' | 'bar'`)
+      : never
+    : abiItem
+  : never
+
+export type EventDefinition = `${string}(${string})`
 
 export type GetValue<
   TAbi extends Abi | readonly unknown[],
@@ -79,6 +313,8 @@ export type GetValue<
       : { value?: never }
   : { value?: TValueType }
 
+//////////////////////////////////////////////////////////////////////////////////////////////////
+
 export type MaybeAbiEventName<TAbiEvent extends AbiEvent | undefined> =
   TAbiEvent extends AbiEvent ? TAbiEvent['name'] : undefined
 
@@ -91,139 +327,9 @@ export type MaybeExtractEventArgsFromAbi<
     : undefined
   : undefined
 
-//////////////////////////////////////////////////////////////////////
-// ABI item name
-
-export type InferErrorName<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TErrorName extends string | undefined = string,
-> = TAbi extends Abi
-  ? ExtractAbiErrorNames<TAbi> extends infer AbiErrorNames
-    ?
-        | AbiErrorNames
-        | (TErrorName extends AbiErrorNames ? TErrorName : never)
-        | (Abi extends TAbi ? string : never)
-    : never
-  : TErrorName
-
-export type InferEventName<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TEventName extends string | undefined = string,
-> = TAbi extends Abi
-  ? ExtractAbiEventNames<TAbi> extends infer AbiEventNames
-    ? AbiEventNames | (TEventName extends AbiEventNames ? TEventName : never)
-    : never
-  : TEventName
-
-export type InferFunctionName<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string | undefined = string,
-  TAbiStateMutability extends AbiStateMutability = AbiStateMutability,
-> = TAbi extends Abi
-  ? ExtractAbiFunctionNames<
-      TAbi,
-      TAbiStateMutability
-    > extends infer AbiFunctionNames
-    ?
-        | AbiFunctionNames
-        | (TFunctionName extends AbiFunctionNames ? TFunctionName : never)
-        | (Abi extends TAbi ? string : never)
-    : never
-  : TFunctionName
-
-export type InferItemName<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TName extends string = string,
-> = TAbi extends Abi
-  ? ExtractAbiItemNames<TAbi> extends infer AbiNames
-    ?
-        | AbiNames
-        | (TName extends AbiNames ? TName : never)
-        | (Abi extends TAbi ? string : never)
-    : never
-  : TName
-type ExtractAbiItemNames<TAbi extends Abi> =
-  | ExtractAbiFunctionNames<TAbi>
-  | ExtractAbiEventNames<TAbi>
-  | ExtractAbiErrorNames<TAbi>
-
 //////////////////////////////////////////////////////////////////////
 // ABI item args
 
-export type GetFunctionArgs<
-  TAbi extends Abi | readonly unknown[],
-  TFunctionName extends string,
-  TAbiFunction extends AbiFunction = TAbi extends Abi
-    ? ExtractAbiFunction<TAbi, TFunctionName>
-    : AbiFunction,
-  TArgs = AbiParametersToPrimitiveTypes<TAbiFunction['inputs']>,
-  FailedToParseArgs =
-    | ([TArgs] extends [never] ? true : false)
-    | (readonly unknown[] extends TArgs ? true : false),
-> = true extends FailedToParseArgs
-  ? {
-      /**
-       * Arguments to pass contract method
-       *
-       * Use a [const assertion](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-4.html#const-assertions) on {@link abi} for type inference.
-       */
-      args?: readonly unknown[]
-    }
-  : TArgs extends readonly []
-    ? { args?: never }
-    : {
-        /** Arguments to pass contract method */ args: TArgs
-      }
-
-export type GetConstructorArgs<
-  TAbi extends Abi | readonly unknown[],
-  TAbiConstructor extends AbiConstructor = TAbi extends Abi
-    ? Extract<TAbi[number], { type: 'constructor' }>
-    : AbiConstructor,
-  TArgs = AbiParametersToPrimitiveTypes<TAbiConstructor['inputs']>,
-  FailedToParseArgs =
-    | ([TArgs] extends [never] ? true : false)
-    | (readonly unknown[] extends TArgs ? true : false),
-> = true extends FailedToParseArgs
-  ? {
-      /**
-       * Arguments to pass contract constructor
-       *
-       * Use a [const assertion](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-4.html#const-assertions) on {@link abi} for type inference.
-       */
-      args?: readonly unknown[]
-    }
-  : TArgs extends readonly []
-    ? { args?: never }
-    : {
-        /** Arguments to pass contract constructor */ args: TArgs
-      }
-
-export type GetErrorArgs<
-  TAbi extends Abi | readonly unknown[],
-  TErrorName extends string,
-  TAbiError extends AbiError = TAbi extends Abi
-    ? ExtractAbiError<TAbi, TErrorName>
-    : AbiError,
-  TArgs = AbiParametersToPrimitiveTypes<TAbiError['inputs']>,
-  FailedToParseArgs =
-    | ([TArgs] extends [never] ? true : false)
-    | (readonly unknown[] extends TArgs ? true : false),
-> = true extends FailedToParseArgs
-  ? {
-      /**
-       * Arguments to pass contract method
-       *
-       * Use a [const assertion](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-4.html#const-assertions) on {@link abi} for type inference.
-       */
-      args?: readonly unknown[]
-    }
-  : TArgs extends readonly []
-    ? { args?: never }
-    : {
-        /** Arguments to pass contract method */ args: TArgs
-      }
-
 export type GetEventArgs<
   TAbi extends Abi | readonly unknown[],
   TEventName extends string,
@@ -239,25 +345,6 @@ export type GetEventArgs<
   ? readonly unknown[] | Record<string, unknown>
   : TArgs
 
-export type GetEventArgsFromTopics<
-  TAbi extends Abi | readonly unknown[],
-  TEventName extends string,
-  TTopics extends LogTopic[],
-  TData extends Hex | undefined,
-  TStrict extends boolean = true,
-  TAbiEvent extends AbiEvent & { type: 'event' } = TAbi extends Abi
-    ? ExtractAbiEvent<TAbi, TEventName>
-    : AbiEvent & { type: 'event' },
-  TArgs = AbiEventParametersToPrimitiveTypes<
-    TAbiEvent['inputs'],
-    { EnableUnion: false; IndexedOnly: false; Required: TStrict }
-  >,
-> = TTopics extends readonly []
-  ? TData extends undefined
-    ? { args?: never }
-    : { args?: TArgs }
-  : { args: TArgs }
-
 //////////////////////////////////////////////////////////////////////
 // ABI event types
 
@@ -272,55 +359,6 @@ type DefaultEventParameterOptions = {
   Required: false
 }
 
-type HashedEventTypes = 'bytes' | 'string' | 'tuple' | `${string}[${string}]`
-
-// TODO: Speed up by returning immediately as soon as named parameter is found.
-type _HasUnnamedAbiParameter<TAbiParameters extends readonly AbiParameter[]> =
-  TAbiParameters extends readonly [
-    infer Head extends AbiParameter,
-    ...infer Tail extends readonly AbiParameter[],
-  ]
-    ? Head extends { name: string }
-      ? Head['name'] extends ''
-        ? true
-        : _HasUnnamedAbiParameter<Tail>
-      : true
-    : false
-
-/**
- * @internal
- */
-export type LogTopicType<
-  TPrimitiveType = Hex,
-  TTopic extends LogTopic = LogTopic,
-> = TTopic extends Hex
-  ? TPrimitiveType
-  : TTopic extends Hex[]
-    ? TPrimitiveType[]
-    : TTopic extends null
-      ? null
-      : never
-
-/**
- * @internal
- */
-export type AbiEventParameterToPrimitiveType<
-  TAbiParameter extends AbiParameter,
-  Options extends EventParameterOptions = DefaultEventParameterOptions,
-  _Type = AbiParameterToPrimitiveType<TAbiParameter>,
-> = Options['EnableUnion'] extends true ? LogTopicType<_Type> : _Type
-
-/**
- * @internal
- */
-export type AbiEventTopicToPrimitiveType<
-  TAbiParameter extends AbiParameter,
-  TTopic extends LogTopic,
-  TPrimitiveType = TAbiParameter['type'] extends HashedEventTypes
-    ? TTopic
-    : AbiParameterToPrimitiveType<TAbiParameter>,
-> = LogTopicType<TPrimitiveType, TTopic>
-
 export type AbiEventParametersToPrimitiveTypes<
   TAbiParameters extends readonly AbiParameter[],
   Options extends EventParameterOptions = DefaultEventParameterOptions,
@@ -370,3 +408,52 @@ export type AbiEventParametersToPrimitiveTypes<
           >
         : never
     : never
+
+// TODO: Speed up by returning immediately as soon as named parameter is found.
+type _HasUnnamedAbiParameter<TAbiParameters extends readonly AbiParameter[]> =
+  TAbiParameters extends readonly [
+    infer Head extends AbiParameter,
+    ...infer Tail extends readonly AbiParameter[],
+  ]
+    ? Head extends { name: string }
+      ? Head['name'] extends ''
+        ? true
+        : _HasUnnamedAbiParameter<Tail>
+      : true
+    : false
+
+/**
+ * @internal
+ */
+export type LogTopicType<
+  TPrimitiveType = Hex,
+  TTopic extends LogTopic = LogTopic,
+> = TTopic extends Hex
+  ? TPrimitiveType
+  : TTopic extends Hex[]
+    ? TPrimitiveType[]
+    : TTopic extends null
+      ? null
+      : never
+
+/**
+ * @internal
+ */
+export type AbiEventParameterToPrimitiveType<
+  TAbiParameter extends AbiParameter,
+  Options extends EventParameterOptions = DefaultEventParameterOptions,
+  _Type = AbiParameterToPrimitiveType<TAbiParameter>,
+> = Options['EnableUnion'] extends true ? LogTopicType<_Type> : _Type
+
+type HashedEventTypes = 'bytes' | 'string' | 'tuple' | `${string}[${string}]`
+
+/**
+ * @internal
+ */
+export type AbiEventTopicToPrimitiveType<
+  TAbiParameter extends AbiParameter,
+  TTopic extends LogTopic,
+  TPrimitiveType = TAbiParameter['type'] extends HashedEventTypes
+    ? TTopic
+    : AbiParameterToPrimitiveType<TAbiParameter>,
+> = LogTopicType<TPrimitiveType, TTopic>

package/types/eip1193.ts

@@ -22,9 +22,11 @@ import type { Prettify } from './utils.js'
 
 export type EIP1474Methods = [...PublicRpcSchema, ...WalletRpcSchema]
 
-export type EIP1193Provider = EIP1193Events & {
-  request: EIP1193RequestFn<EIP1474Methods>
-}
+export type EIP1193Provider = Prettify<
+  EIP1193Events & {
+    request: EIP1193RequestFn<EIP1474Methods>
+  }
+>
 
 //////////////////////////////////////////////////
 // Errors
@@ -1340,6 +1342,13 @@ export type EIP1193Parameters<
       params?: unknown
     }
 
+export type EIP1193RequestOptions = {
+  // The base delay (in ms) between retries.
+  retryDelay?: number
+  // The max number of times to retry.
+  retryCount?: number
+}
+
 type DerivedRpcSchema<
   TRpcSchema extends RpcSchema | undefined,
   TRpcSchemaOverride extends RpcSchemaOverride | undefined,
@@ -1365,4 +1374,5 @@ export type EIP1193RequestFn<
     : unknown,
 >(
   args: TParameters,
+  options?: EIP1193RequestOptions,
 ) => Promise<_ReturnType>

package/types/misc.ts

@@ -9,16 +9,11 @@ export type SignableMessage =
       raw: Hex | ByteArray
     }
 export type Signature = {
-  // TODO(v2): Make `bigint`
   r: Hex
-  // TODO(v2): Make `bigint`
   s: Hex
-  // TODO(v2): `v` to `recovery`
   v: bigint
 }
 export type CompactSignature = {
-  // TODO(v2): Make `bigint`
   r: Hex
-  // TODO(v2): Make `bigint`
   yParityAndS: Hex
 }