rocketh 0.10.13 → 0.10.15

package/dist/index.d.ts

@@ -681,39 +681,51 @@ type EIP1193ChainId = `0x${string}`;
 type EIP1193Account = `0x${string}`;
 type EIP1193Accounts = EIP1193Account[];
 
-type Register = {};
+interface Register {
+}
 type ResolvedRegister = {
     /**
      * TypeScript type to use for `address` values
      * @default `0x${string}`
      */
-    AddressType: Register extends {
+    addressType: Register extends {
+        addressType: infer type;
+    } ? type : Register extends {
         AddressType: infer type;
-    } ? type : DefaultRegister['AddressType'];
+    } ? type : DefaultRegister['addressType'];
     /**
      * TypeScript type to use for `int<M>` and `uint<M>` values, where `M > 48`
      * @default bigint
      */
-    BigIntType: Register extends {
+    bigIntType: Register extends {
+        bigIntType: infer type;
+    } ? type : Register extends {
         BigIntType: infer type;
-    } ? type : DefaultRegister['BigIntType'];
+    } ? type : DefaultRegister['bigIntType'];
     /**
      * TypeScript type to use for `bytes` values
      * @default { inputs: `0x${string}`; outputs: `0x${string}`; }
      */
-    BytesType: Register extends {
+    bytesType: Register extends {
+        bytesType: infer type extends {
+            inputs: unknown;
+            outputs: unknown;
+        };
+    } ? type : Register extends {
         BytesType: infer type extends {
             inputs: unknown;
             outputs: unknown;
         };
-    } ? type : DefaultRegister['BytesType'];
+    } ? type : DefaultRegister['bytesType'];
     /**
      * TypeScript type to use for `int<M>` and `uint<M>` values, where `M <= 48`
      * @default number
      */
-    IntType: Register extends {
+    intType: Register extends {
+        intType: infer type;
+    } ? type : Register extends {
         IntType: infer type;
-    } ? type : DefaultRegister['IntType'];
+    } ? type : DefaultRegister['intType'];
     /**
      * Maximum depth for nested array types (e.g. string[][])
      *
@@ -722,23 +734,29 @@ type ResolvedRegister = {
      *
      * @default false
      */
-    ArrayMaxDepth: Register extends {
+    arrayMaxDepth: Register extends {
+        arrayMaxDepth: infer type extends number | false;
+    } ? type : Register extends {
         ArrayMaxDepth: infer type extends number | false;
-    } ? type : DefaultRegister['ArrayMaxDepth'];
+    } ? type : DefaultRegister['arrayMaxDepth'];
     /**
      * Lower bound for fixed array length
      * @default 1
      */
-    FixedArrayMinLength: Register extends {
+    fixedArrayMinLength: Register extends {
+        fixedArrayMinLength: infer type extends number;
+    } ? type : Register extends {
         FixedArrayMinLength: infer type extends number;
-    } ? type : DefaultRegister['FixedArrayMinLength'];
+    } ? type : DefaultRegister['fixedArrayMinLength'];
     /**
      * Upper bound for fixed array length
      * @default 99
      */
-    FixedArrayMaxLength: Register extends {
+    fixedArrayMaxLength: Register extends {
+        fixedArrayMaxLength: infer type extends number;
+    } ? type : Register extends {
         FixedArrayMaxLength: infer type extends number;
-    } ? type : DefaultRegister['FixedArrayMaxLength'];
+    } ? type : DefaultRegister['fixedArrayMaxLength'];
     /**
      * When set, validates {@link AbiParameter}'s `type` against {@link AbiType}
      *
@@ -747,32 +765,69 @@ type ResolvedRegister = {
      *
      * @default false
      */
-    StrictAbiType: Register extends {
+    strictAbiType: Register extends {
+        strictAbiType: infer type extends boolean;
+    } ? type : Register extends {
         StrictAbiType: infer type extends boolean;
-    } ? type : DefaultRegister['StrictAbiType'];
+    } ? type : DefaultRegister['strictAbiType'];
+    /** @deprecated Use `addressType` instead */
+    AddressType: ResolvedRegister['addressType'];
+    /** @deprecated Use `addressType` instead */
+    BigIntType: ResolvedRegister['bigIntType'];
+    /** @deprecated Use `bytesType` instead */
+    BytesType: ResolvedRegister['bytesType'];
+    /** @deprecated Use `intType` instead */
+    IntType: ResolvedRegister['intType'];
+    /** @deprecated Use `arrayMaxDepth` instead */
+    ArrayMaxDepth: ResolvedRegister['arrayMaxDepth'];
+    /** @deprecated Use `fixedArrayMinLength` instead */
+    FixedArrayMinLength: ResolvedRegister['fixedArrayMinLength'];
+    /** @deprecated Use `fixedArrayMaxLength` instead */
+    FixedArrayMaxLength: ResolvedRegister['fixedArrayMaxLength'];
+    /** @deprecated Use `strictAbiType` instead */
+    StrictAbiType: ResolvedRegister['strictAbiType'];
 };
 type DefaultRegister = {
     /** Maximum depth for nested array types (e.g. string[][]) */
-    ArrayMaxDepth: false;
+    arrayMaxDepth: false;
     /** Lower bound for fixed array length */
-    FixedArrayMinLength: 1;
+    fixedArrayMinLength: 1;
     /** Upper bound for fixed array length */
-    FixedArrayMaxLength: 99;
+    fixedArrayMaxLength: 99;
     /** TypeScript type to use for `address` values */
-    AddressType: `0x${string}`;
+    addressType: `0x${string}`;
     /** TypeScript type to use for `bytes` values */
-    BytesType: {
+    bytesType: {
         /** TypeScript type to use for `bytes` input values */
         inputs: `0x${string}`;
         /** TypeScript type to use for `bytes` output values */
         outputs: `0x${string}`;
     };
     /** TypeScript type to use for `int<M>` and `uint<M>` values, where `M > 48` */
-    BigIntType: bigint;
+    bigIntType: bigint;
     /** TypeScript type to use for `int<M>` and `uint<M>` values, where `M <= 48` */
-    IntType: number;
+    intType: number;
     /** When set, validates {@link AbiParameter}'s `type` against {@link AbiType} */
-    StrictAbiType: false;
+    strictAbiType: false;
+    /** @deprecated Use `arrayMaxDepth` instead */
+    ArrayMaxDepth: DefaultRegister['arrayMaxDepth'];
+    /** @deprecated Use `fixedArrayMinLength` instead */
+    FixedArrayMinLength: DefaultRegister['fixedArrayMinLength'];
+    /** @deprecated Use `fixedArrayMaxLength` instead */
+    FixedArrayMaxLength: DefaultRegister['fixedArrayMaxLength'];
+    /** @deprecated Use `addressType` instead */
+    AddressType: DefaultRegister['addressType'];
+    /** @deprecated Use `bytesType` instead */
+    BytesType: {
+        inputs: DefaultRegister['bytesType']['inputs'];
+        outputs: DefaultRegister['bytesType']['outputs'];
+    };
+    /** @deprecated Use `bigIntType` instead */
+    BigIntType: DefaultRegister['bigIntType'];
+    /** @deprecated Use `intType` instead */
+    IntType: DefaultRegister['intType'];
+    /** @deprecated Use `strictAbiType` instead */
+    StrictAbiType: DefaultRegister['strictAbiType'];
 };
 
 /**
@@ -783,21 +838,21 @@ type DefaultRegister = {
  * type Result = Pretty<{ a: string } | { b: string } | { c: number, d: bigint }>
  * //   ^? type Result = { a: string; b: string; c: number; d: bigint }
  */
-type Pretty<T> = {
-    [K in keyof T]: T[K];
+type Pretty<type> = {
+    [key in keyof type]: type[key];
 } & unknown;
 /**
  * Creates range between two positive numbers using [tail recursion](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-5.html#tail-recursion-elimination-on-conditional-types).
  *
- * @param Start - Number to start range
- * @param Stop - Number to end range
- * @returns Array with inclusive range from {@link Start} to {@link Stop}
+ * @param start - Number to start range
+ * @param stop - Number to end range
+ * @returns Array with inclusive range from {@link start} to {@link stop}
  *
  * @example
  * type Result = Range<1, 3>
  * //   ^? type Result = [1, 2, 3]
  */
-type Range<Start extends number, Stop extends number, Result extends number[] = [], Padding extends 0[] = [], Current extends number = [...Padding, ...Result]['length'] & number> = Current extends Stop ? Current extends Start ? [Current] : Result extends [] ? [] : [...Result, Current] : Current extends Start ? Range<Start, Stop, [Current], Padding> : Result extends [] ? Range<Start, Stop, [], [...Padding, 0]> : Range<Start, Stop, [...Result, Current], Padding>;
+type Range<start extends number, stop extends number, result extends number[] = [], padding extends 0[] = [], current extends number = [...padding, ...result]['length'] & number> = current extends stop ? current extends start ? [current] : result extends [] ? [] : [...result, current] : current extends start ? Range<start, stop, [current], padding> : result extends [] ? Range<start, stop, [], [...padding, 0]> : Range<start, stop, [...result, current], padding>;
 
 type MBytes = '' | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32;
 type MBits = '' | 8 | 16 | 24 | 32 | 40 | 48 | 56 | 64 | 72 | 80 | 88 | 96 | 104 | 112 | 120 | 128 | 136 | 144 | 152 | 160 | 168 | 176 | 184 | 192 | 200 | 208 | 216 | 224 | 232 | 240 | 248 | 256;
@@ -808,17 +863,20 @@ type SolidityFunction = 'function';
 type SolidityString = 'string';
 type SolidityTuple = 'tuple';
 type SolidityInt = `${'u' | ''}int${MBits}`;
-type SolidityFixedArrayRange = Range<ResolvedRegister['FixedArrayMinLength'], ResolvedRegister['FixedArrayMaxLength']>[number];
+type SolidityFixedArrayRange = Range<ResolvedRegister['fixedArrayMinLength'], ResolvedRegister['fixedArrayMaxLength']>[number];
 /**
  * Recursively build arrays up to maximum depth
  * or use a more broad type when maximum depth is switched "off"
  */
-type _BuildArrayTypes<T extends string, Depth extends readonly number[] = []> = ResolvedRegister['ArrayMaxDepth'] extends false ? `${T}[${string}]` : Depth['length'] extends ResolvedRegister['ArrayMaxDepth'] ? T : T extends `${any}[${SolidityFixedArrayRange | ''}]` ? _BuildArrayTypes<T | `${T}[${SolidityFixedArrayRange | ''}]`, [...Depth, 1]> : _BuildArrayTypes<`${T}[${SolidityFixedArrayRange | ''}]`, [...Depth, 1]>;
+type _BuildArrayTypes<T extends string, Depth extends readonly number[] = []> = ResolvedRegister['arrayMaxDepth'] extends false ? `${T}[${string}]` : Depth['length'] extends ResolvedRegister['arrayMaxDepth'] ? T : T extends `${any}[${SolidityFixedArrayRange | ''}]` ? _BuildArrayTypes<T | `${T}[${SolidityFixedArrayRange | ''}]`, [
+    ...Depth,
+    1
+]> : _BuildArrayTypes<`${T}[${SolidityFixedArrayRange | ''}]`, [...Depth, 1]>;
 type SolidityArrayWithoutTuple = _BuildArrayTypes<SolidityAddress | SolidityBool | SolidityBytes | SolidityFunction | SolidityInt | SolidityString>;
 type SolidityArrayWithTuple = _BuildArrayTypes<SolidityTuple>;
 type SolidityArray = SolidityArrayWithoutTuple | SolidityArrayWithTuple;
 type AbiType = SolidityArray | SolidityAddress | SolidityBool | SolidityBytes | SolidityFunction | SolidityInt | SolidityString | SolidityTuple;
-type ResolvedAbiType = ResolvedRegister['StrictAbiType'] extends true ? AbiType : string;
+type ResolvedAbiType = ResolvedRegister['strictAbiType'] extends true ? AbiType : string;
 type AbiInternalType = ResolvedAbiType | `address ${string}` | `contract ${string}` | `enum ${string}` | `struct ${string}`;
 type AbiParameter = Pretty<{
     type: ResolvedAbiType;
@@ -831,9 +889,9 @@ type AbiParameter = Pretty<{
     type: SolidityTuple | SolidityArrayWithTuple;
     components: readonly AbiParameter[];
 })>;
-type AbiEventParameter = Pretty<AbiParameter & {
+type AbiEventParameter = AbiParameter & {
     indexed?: boolean | undefined;
-}>;
+};
 /**
  * State mutability for {@link AbiFunction}
  *
@@ -912,13 +970,13 @@ type Abi = readonly (AbiConstructor | AbiError | AbiEvent | AbiFallback | AbiFun
  * Infers embedded primitive type of any type
  *
  * @param T - Type to infer
- * @returns Embedded type of {@link TType}
+ * @returns Embedded type of {@link type}
  *
  * @example
  * type Result = Narrow<['foo', 'bar', 1]>
  */
-type Narrow<TType> = (unknown extends TType ? unknown : never) | (TType extends Function ? TType : never) | (TType extends bigint | boolean | number | string ? TType : never) | (TType extends [] ? [] : never) | {
-    [K in keyof TType]: Narrow<TType[K]>;
+type Narrow<type> = (unknown extends type ? unknown : never) | (type extends Function ? type : never) | (type extends bigint | boolean | number | string ? type : never) | (type extends [] ? [] : never) | {
+    [K in keyof type]: Narrow<type[K]>;
 };
 
 type ProgressIndicator = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rocketh",
-  "version": "0.10.13",
+  "version": "0.10.15",
   "description": "deploy smart contract on ethereum-compatible networks",
   "publishConfig": {
     "access": "public"
@@ -23,29 +23,29 @@
     "rocketh": "dist/cli.cjs"
   },
   "devDependencies": {
-    "@types/node": "^20.12.7",
-    "abitype": "^1.0.2",
+    "@types/node": "^20.14.8",
+    "abitype": "^1.0.4",
     "eip-1193": "^0.5.0",
     "ipfs-gateway-emulator": "4.2.1-ipfs.2",
-    "pkgroll": "^2.0.2",
-    "rimraf": "^5.0.5",
-    "typedoc": "^0.25.13",
-    "typescript": "^5.4.5"
+    "pkgroll": "^2.1.1",
+    "rimraf": "^5.0.7",
+    "typedoc": "^0.26.2",
+    "typescript": "^5.5.2"
   },
   "dependencies": {
     "@types/figlet": "^1.5.8",
     "@types/prompts": "^2.4.9",
-    "commander": "^12.0.0",
-    "eip-1193-jsonrpc-provider": "^0.3.0",
-    "esbuild": "^0.20.2",
-    "esbuild-register": "^3.5.0",
-    "ethers": "^6.11.1",
+    "commander": "^12.1.0",
+    "eip-1193-jsonrpc-provider": "^0.4.0",
+    "esbuild": "^0.25.0",
+    "esbuild-register": "^3.6.0",
+    "ethers": "^6.13.1",
     "figlet": "^1.7.0",
     "ldenv": "^0.3.10",
     "named-logs": "^0.2.4",
     "named-logs-console": "^0.3.1",
     "prompts": "^2.4.2",
-    "viem": "^2.9.16"
+    "viem": "^2.16.2"
   },
   "scripts": {
     "build": "rimraf dist && pkgroll --sourcemap",