Socket
Socket
Sign inDemoInstall

abitype

Package Overview
Dependencies
Maintainers
0
Versions
180
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

abitype - npm Package Compare versions

Comparing version 0.0.0-canary.20240315T081554 to 0.0.0-canary-20240620192132

abis/package.json
LICENSE
zod/package.json

3

dist/cjs/human-readable/formatAbi.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.formatAbi = void 0;
exports.formatAbi = formatAbi;
const formatAbiItem_js_1 = require("./formatAbiItem.js");

@@ -15,3 +15,2 @@ function formatAbi(abi) {

}
exports.formatAbi = formatAbi;
//# sourceMappingURL=formatAbi.js.map

11

dist/cjs/human-readable/formatAbiItem.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.formatAbiItem = void 0;
exports.formatAbiItem = formatAbiItem;
const formatAbiParameters_js_1 = require("./formatAbiParameters.js");

@@ -12,13 +12,12 @@ function formatAbiItem(abiItem) {

: ''}`;
else if (abiItem.type === 'event')
if (abiItem.type === 'event')
return `event ${abiItem.name}(${(0, formatAbiParameters_js_1.formatAbiParameters)(abiItem.inputs)})`;
else if (abiItem.type === 'error')
if (abiItem.type === 'error')
return `error ${abiItem.name}(${(0, formatAbiParameters_js_1.formatAbiParameters)(abiItem.inputs)})`;
else if (abiItem.type === 'constructor')
if (abiItem.type === 'constructor')
return `constructor(${(0, formatAbiParameters_js_1.formatAbiParameters)(abiItem.inputs)})${abiItem.stateMutability === 'payable' ? ' payable' : ''}`;
else if (abiItem.type === 'fallback')
if (abiItem.type === 'fallback')
return 'fallback()';
return 'receive() external payable';
}
exports.formatAbiItem = formatAbiItem;
//# sourceMappingURL=formatAbiItem.js.map

3

dist/cjs/human-readable/formatAbiParameter.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.formatAbiParameter = void 0;
exports.formatAbiParameter = formatAbiParameter;
const regex_js_1 = require("../regex.js");

@@ -30,3 +30,2 @@ const tupleRegex = /^tuple(?<array>(\[(\d*)\])*)$/;

}
exports.formatAbiParameter = formatAbiParameter;
//# sourceMappingURL=formatAbiParameter.js.map

3

dist/cjs/human-readable/formatAbiParameters.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.formatAbiParameters = void 0;
exports.formatAbiParameters = formatAbiParameters;
const formatAbiParameter_js_1 = require("./formatAbiParameter.js");

@@ -16,3 +16,2 @@ function formatAbiParameters(abiParameters) {

}
exports.formatAbiParameters = formatAbiParameters;
//# sourceMappingURL=formatAbiParameters.js.map

3

dist/cjs/human-readable/parseAbi.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.parseAbi = void 0;
exports.parseAbi = parseAbi;
const signatures_js_1 = require("./runtime/signatures.js");

@@ -19,3 +19,2 @@ const structs_js_1 = require("./runtime/structs.js");

}
exports.parseAbi = parseAbi;
//# sourceMappingURL=parseAbi.js.map

3

dist/cjs/human-readable/parseAbiItem.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.parseAbiItem = void 0;
exports.parseAbiItem = parseAbiItem;
const abiItem_js_1 = require("./errors/abiItem.js");

@@ -27,3 +27,2 @@ const signatures_js_1 = require("./runtime/signatures.js");

}
exports.parseAbiItem = parseAbiItem;
//# sourceMappingURL=parseAbiItem.js.map

3

dist/cjs/human-readable/parseAbiParameter.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.parseAbiParameter = void 0;
exports.parseAbiParameter = parseAbiParameter;
const abiParameter_js_1 = require("./errors/abiParameter.js");

@@ -29,3 +29,2 @@ const signatures_js_1 = require("./runtime/signatures.js");

}
exports.parseAbiParameter = parseAbiParameter;
//# sourceMappingURL=parseAbiParameter.js.map

3

dist/cjs/human-readable/parseAbiParameters.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.parseAbiParameters = void 0;
exports.parseAbiParameters = parseAbiParameters;
const abiParameter_js_1 = require("./errors/abiParameter.js");

@@ -36,3 +36,2 @@ const signatures_js_1 = require("./runtime/signatures.js");

}
exports.parseAbiParameters = parseAbiParameters;
//# sourceMappingURL=parseAbiParameters.js.map

4

dist/cjs/human-readable/runtime/cache.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.parameterCache = exports.getParameterCacheKey = void 0;
exports.parameterCache = void 0;
exports.getParameterCacheKey = getParameterCacheKey;
function getParameterCacheKey(param, type) {

@@ -9,3 +10,2 @@ if (type)

}
exports.getParameterCacheKey = getParameterCacheKey;
exports.parameterCache = new Map([

@@ -12,0 +12,0 @@ ['address', { type: 'address' }],

26

dist/cjs/human-readable/runtime/signatures.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.functionModifiers = exports.eventModifiers = exports.modifiers = exports.isReceiveSignature = exports.isFallbackSignature = exports.execConstructorSignature = exports.isConstructorSignature = exports.execStructSignature = exports.isStructSignature = exports.execFunctionSignature = exports.isFunctionSignature = exports.execEventSignature = exports.isEventSignature = exports.execErrorSignature = exports.isErrorSignature = void 0;
exports.functionModifiers = exports.eventModifiers = exports.modifiers = void 0;
exports.isErrorSignature = isErrorSignature;
exports.execErrorSignature = execErrorSignature;
exports.isEventSignature = isEventSignature;
exports.execEventSignature = execEventSignature;
exports.isFunctionSignature = isFunctionSignature;
exports.execFunctionSignature = execFunctionSignature;
exports.isStructSignature = isStructSignature;
exports.execStructSignature = execStructSignature;
exports.isConstructorSignature = isConstructorSignature;
exports.execConstructorSignature = execConstructorSignature;
exports.isFallbackSignature = isFallbackSignature;
exports.isReceiveSignature = isReceiveSignature;
const regex_js_1 = require("../../regex.js");

@@ -9,7 +21,5 @@ const errorSignatureRegex = /^error (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;

}
exports.isErrorSignature = isErrorSignature;
function execErrorSignature(signature) {
return (0, regex_js_1.execTyped)(errorSignatureRegex, signature);
}
exports.execErrorSignature = execErrorSignature;
const eventSignatureRegex = /^event (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;

@@ -19,7 +29,5 @@ function isEventSignature(signature) {

}
exports.isEventSignature = isEventSignature;
function execEventSignature(signature) {
return (0, regex_js_1.execTyped)(eventSignatureRegex, signature);
}
exports.execEventSignature = execEventSignature;
const functionSignatureRegex = /^function (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)(?: (?<scope>external|public{1}))?(?: (?<stateMutability>pure|view|nonpayable|payable{1}))?(?: returns\s?\((?<returns>.*?)\))?$/;

@@ -29,7 +37,5 @@ function isFunctionSignature(signature) {

}
exports.isFunctionSignature = isFunctionSignature;
function execFunctionSignature(signature) {
return (0, regex_js_1.execTyped)(functionSignatureRegex, signature);
}
exports.execFunctionSignature = execFunctionSignature;
const structSignatureRegex = /^struct (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*) \{(?<properties>.*?)\}$/;

@@ -39,7 +45,5 @@ function isStructSignature(signature) {

}
exports.isStructSignature = isStructSignature;
function execStructSignature(signature) {
return (0, regex_js_1.execTyped)(structSignatureRegex, signature);
}
exports.execStructSignature = execStructSignature;
const constructorSignatureRegex = /^constructor\((?<parameters>.*?)\)(?:\s(?<stateMutability>payable{1}))?$/;

@@ -49,7 +53,5 @@ function isConstructorSignature(signature) {

}
exports.isConstructorSignature = isConstructorSignature;
function execConstructorSignature(signature) {
return (0, regex_js_1.execTyped)(constructorSignatureRegex, signature);
}
exports.execConstructorSignature = execConstructorSignature;
const fallbackSignatureRegex = /^fallback\(\) external(?:\s(?<stateMutability>payable{1}))?$/;

@@ -59,3 +61,2 @@ function isFallbackSignature(signature) {

}
exports.isFallbackSignature = isFallbackSignature;
const receiveSignatureRegex = /^receive\(\) external payable$/;

@@ -65,3 +66,2 @@ function isReceiveSignature(signature) {

}
exports.isReceiveSignature = isReceiveSignature;
exports.modifiers = new Set([

@@ -68,0 +68,0 @@ 'memory',

3

dist/cjs/human-readable/runtime/structs.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.parseStructs = void 0;
exports.parseStructs = parseStructs;
const regex_js_1 = require("../../regex.js");

@@ -47,3 +47,2 @@ const abiItem_js_1 = require("../errors/abiItem.js");

}
exports.parseStructs = parseStructs;
const typeWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?$/;

@@ -50,0 +49,0 @@ function resolveStructs(abiParameters, structs, ancestors = new Set()) {

13

dist/cjs/human-readable/runtime/utils.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.isValidDataLocation = exports.isSolidityKeyword = exports.isSolidityType = exports.splitParameters = exports.parseAbiParameter = exports.parseSignature = void 0;
exports.parseSignature = parseSignature;
exports.parseAbiParameter = parseAbiParameter;
exports.splitParameters = splitParameters;
exports.isSolidityType = isSolidityType;
exports.isSolidityKeyword = isSolidityKeyword;
exports.isValidDataLocation = isValidDataLocation;
const regex_js_1 = require("../../regex.js");

@@ -99,3 +104,2 @@ const abiItem_js_1 = require("../errors/abiItem.js");

}
exports.parseSignature = parseSignature;
const abiParameterWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;

@@ -165,3 +169,2 @@ const abiParameterWithTupleRegex = /^\((?<type>.+?)\)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;

}
exports.parseAbiParameter = parseAbiParameter;
function splitParameters(params, result = [], current = '', depth = 0) {

@@ -192,3 +195,2 @@ const length = params.trim().length;

}
exports.splitParameters = splitParameters;
function isSolidityType(type) {

@@ -202,3 +204,2 @@ return (type === 'address' ||

}
exports.isSolidityType = isSolidityType;
const protectedKeywordsRegex = /^(?:after|alias|anonymous|apply|auto|byte|calldata|case|catch|constant|copyof|default|defined|error|event|external|false|final|function|immutable|implements|in|indexed|inline|internal|let|mapping|match|memory|mutable|null|of|override|partial|private|promise|public|pure|reference|relocatable|return|returns|sizeof|static|storage|struct|super|supports|switch|this|true|try|typedef|typeof|var|view|virtual)$/;

@@ -215,7 +216,5 @@ function isSolidityKeyword(name) {

}
exports.isSolidityKeyword = isSolidityKeyword;
function isValidDataLocation(type, isArray) {
return isArray || type === 'bytes' || type === 'string' || type === 'tuple';
}
exports.isValidDataLocation = isValidDataLocation;
//# sourceMappingURL=utils.js.map

3

dist/cjs/narrow.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.narrow = void 0;
exports.narrow = narrow;
function narrow(value) {
return value;
}
exports.narrow = narrow;
//# sourceMappingURL=narrow.js.map

4

dist/cjs/regex.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.isTupleRegex = exports.integerRegex = exports.bytesRegex = exports.execTyped = void 0;
exports.isTupleRegex = exports.integerRegex = exports.bytesRegex = void 0;
exports.execTyped = execTyped;
function execTyped(regex, string) {

@@ -8,3 +9,2 @@ const match = regex.exec(string);

}
exports.execTyped = execTyped;
exports.bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;

@@ -11,0 +11,0 @@ exports.integerRegex = /^u?int(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)?$/;

2

dist/cjs/version.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.version = void 0;
exports.version = '0.0.0-canary.20240315T081554';
exports.version = '0.0.0-canary-20240620192132';
//# sourceMappingURL=version.js.map

8

dist/esm/human-readable/formatAbiItem.js

@@ -15,9 +15,9 @@ import { formatAbiParameters, } from './formatAbiParameters.js';

: ''}`;
else if (abiItem.type === 'event')
if (abiItem.type === 'event')
return `event ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
else if (abiItem.type === 'error')
if (abiItem.type === 'error')
return `error ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
else if (abiItem.type === 'constructor')
if (abiItem.type === 'constructor')
return `constructor(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability === 'payable' ? ' payable' : ''}`;
else if (abiItem.type === 'fallback')
if (abiItem.type === 'fallback')
return 'fallback()';

@@ -24,0 +24,0 @@ return 'receive() external payable';

2

dist/esm/version.js

@@ -1,2 +0,2 @@

export const version = '0.0.0-canary.20240315T081554';
export const version = '0.0.0-canary-20240620192132';
//# sourceMappingURL=version.js.map

17

dist/types/abi.d.ts
import type { ResolvedRegister } from './register.js';
import type { Pretty, Range } from './types.js';
export type Address = ResolvedRegister['AddressType'];
export type Address = ResolvedRegister['addressType'];
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;

@@ -13,3 +13,3 @@ export 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;

export type SolidityInt = `${'u' | ''}int${MBits}`;
export type SolidityFixedArrayRange = Range<ResolvedRegister['FixedArrayMinLength'], ResolvedRegister['FixedArrayMaxLength']>[number];
export type SolidityFixedArrayRange = Range<ResolvedRegister['fixedArrayMinLength'], ResolvedRegister['fixedArrayMaxLength']>[number];
export type SolidityFixedArraySizeLookup = {

@@ -22,3 +22,6 @@ [Prop in SolidityFixedArrayRange as `${Prop}`]: Prop;

*/
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]>;
export type SolidityArrayWithoutTuple = _BuildArrayTypes<SolidityAddress | SolidityBool | SolidityBytes | SolidityFunction | SolidityInt | SolidityString>;

@@ -28,3 +31,3 @@ export type SolidityArrayWithTuple = _BuildArrayTypes<SolidityTuple>;

export 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;
export type AbiInternalType = ResolvedAbiType | `address ${string}` | `contract ${string}` | `enum ${string}` | `struct ${string}`;

@@ -42,5 +45,5 @@ export type AbiParameter = Pretty<{

})>;
export type AbiEventParameter = Pretty<AbiParameter & {
export type AbiEventParameter = AbiParameter & {
indexed?: boolean | undefined;
}>;
};
/**

@@ -126,3 +129,3 @@ * State mutability for {@link AbiFunction}

name?: string | undefined;
salt?: ResolvedRegister['BytesType']['outputs'] | undefined;
salt?: ResolvedRegister['bytesType']['outputs'] | undefined;
verifyingContract?: Address | undefined;

@@ -129,0 +132,0 @@ version?: string | undefined;

8

dist/types/human-readable/formatAbi.d.ts

@@ -6,7 +6,7 @@ import type { Abi } from '../abi.js';

*
* @param TAbi - ABI
* @param abi - ABI
* @returns Human-readable ABI
*/
export type FormatAbi<TAbi extends Abi | readonly unknown[]> = Abi extends TAbi ? readonly string[] : TAbi extends readonly [] ? never : TAbi extends Abi ? {
[K in keyof TAbi]: FormatAbiItem<TAbi[K]>;
export type FormatAbi<abi extends Abi | readonly unknown[]> = Abi extends abi ? readonly string[] : abi extends readonly [] ? never : abi extends Abi ? {
[key in keyof abi]: FormatAbiItem<abi[key]>;
} : readonly string[];

@@ -19,3 +19,3 @@ /**

*/
export declare function formatAbi<const TAbi extends Abi | readonly unknown[]>(abi: TAbi): FormatAbi<TAbi>;
export declare function formatAbi<const abi extends Abi | readonly unknown[]>(abi: abi): FormatAbi<abi>;
//# sourceMappingURL=formatAbi.d.ts.map

10

dist/types/human-readable/formatAbiItem.d.ts

@@ -7,10 +7,10 @@ import type { Abi, AbiConstructor, AbiError, AbiEvent, AbiEventParameter, AbiFallback, AbiFunction, AbiParameter, AbiReceive, AbiStateMutability } from '../abi.js';

*
* @param TAbiItem - ABI item
* @param abiItem - ABI item
* @returns Human-readable ABI item
*/
export type FormatAbiItem<TAbiItem extends Abi[number]> = Abi[number] extends TAbiItem ? string : (TAbiItem extends AbiFunction ? AbiFunction extends TAbiItem ? string : `function ${AssertName<TAbiItem['name']>}(${FormatAbiParameters<TAbiItem['inputs']>})${TAbiItem['stateMutability'] extends Exclude<AbiStateMutability, 'nonpayable'> ? ` ${TAbiItem['stateMutability']}` : ''}${TAbiItem['outputs']['length'] extends 0 ? '' : ` returns (${FormatAbiParameters<TAbiItem['outputs']>})`}` : never) | (TAbiItem extends AbiEvent ? AbiEvent extends TAbiItem ? string : `event ${AssertName<TAbiItem['name']>}(${FormatAbiParameters<TAbiItem['inputs']>})` : never) | (TAbiItem extends AbiError ? AbiError extends TAbiItem ? string : `error ${AssertName<TAbiItem['name']>}(${FormatAbiParameters<TAbiItem['inputs']>})` : never) | (TAbiItem extends AbiConstructor ? AbiConstructor extends TAbiItem ? string : `constructor(${FormatAbiParameters<TAbiItem['inputs']>})${TAbiItem['stateMutability'] extends 'payable' ? ' payable' : ''}` : never) | (TAbiItem extends AbiFallback ? AbiFallback extends TAbiItem ? string : 'fallback()' : never) | (TAbiItem extends AbiReceive ? AbiReceive extends TAbiItem ? string : 'receive() external payable' : never);
type FormatAbiParameters<TAbiParameters extends readonly (AbiParameter | AbiEventParameter)[]> = TAbiParameters['length'] extends 0 ? '' : FormatAbiParameters_<TAbiParameters extends readonly [
export type FormatAbiItem<abiItem extends Abi[number]> = Abi[number] extends abiItem ? string : (abiItem extends AbiFunction ? AbiFunction extends abiItem ? string : `function ${AssertName<abiItem['name']>}(${FormatAbiParameters<abiItem['inputs']>})${abiItem['stateMutability'] extends Exclude<AbiStateMutability, 'nonpayable'> ? ` ${abiItem['stateMutability']}` : ''}${abiItem['outputs']['length'] extends 0 ? '' : ` returns (${FormatAbiParameters<abiItem['outputs']>})`}` : never) | (abiItem extends AbiEvent ? AbiEvent extends abiItem ? string : `event ${AssertName<abiItem['name']>}(${FormatAbiParameters<abiItem['inputs']>})` : never) | (abiItem extends AbiError ? AbiError extends abiItem ? string : `error ${AssertName<abiItem['name']>}(${FormatAbiParameters<abiItem['inputs']>})` : never) | (abiItem extends AbiConstructor ? AbiConstructor extends abiItem ? string : `constructor(${FormatAbiParameters<abiItem['inputs']>})${abiItem['stateMutability'] extends 'payable' ? ' payable' : ''}` : never) | (abiItem extends AbiFallback ? AbiFallback extends abiItem ? string : 'fallback()' : never) | (abiItem extends AbiReceive ? AbiReceive extends abiItem ? string : 'receive() external payable' : never);
type FormatAbiParameters<abiParameters extends readonly (AbiParameter | AbiEventParameter)[]> = abiParameters['length'] extends 0 ? '' : FormatAbiParameters_<abiParameters extends readonly [
AbiParameter | AbiEventParameter,
...(readonly (AbiParameter | AbiEventParameter)[])
] ? TAbiParameters : never>;
] ? abiParameters : never>;
/**

@@ -22,4 +22,4 @@ * Formats ABI item (e.g. error, event, function) into human-readable ABI item

*/
export declare function formatAbiItem<const TAbiItem extends Abi[number]>(abiItem: TAbiItem): FormatAbiItem<TAbiItem>;
export declare function formatAbiItem<const abiItem extends Abi[number]>(abiItem: abiItem): FormatAbiItem<abiItem>;
export {};
//# sourceMappingURL=formatAbiItem.d.ts.map

40

dist/types/human-readable/formatAbiParameter.d.ts

@@ -7,3 +7,3 @@ import type { AbiEventParameter, AbiParameter } from '../abi.js';

*
* @param TAbiParameter - ABI parameter
* @param abiParameter - ABI parameter
* @returns Human-readable ABI parameter

@@ -15,26 +15,26 @@ *

*/
export type FormatAbiParameter<TAbiParameter extends AbiParameter | AbiEventParameter> = TAbiParameter extends {
name?: infer Name extends string;
type: `tuple${infer Array}`;
components: infer Components extends readonly AbiParameter[];
indexed?: infer Indexed extends boolean;
export type FormatAbiParameter<abiParameter extends AbiParameter | AbiEventParameter> = abiParameter extends {
name?: infer name extends string;
type: `tuple${infer array}`;
components: infer components extends readonly AbiParameter[];
indexed?: infer indexed extends boolean;
} ? FormatAbiParameter<{
type: `(${Join<{
[K in keyof Components]: FormatAbiParameter<{
type: Components[K]['type'];
} & (IsNarrowable<Components[K]['name'], string> extends true ? {
name: Components[K]['name'];
} : unknown) & (Components[K] extends {
[key in keyof components]: FormatAbiParameter<{
type: components[key]['type'];
} & (IsNarrowable<components[key]['name'], string> extends true ? {
name: components[key]['name'];
} : unknown) & (components[key] extends {
components: readonly AbiParameter[];
} ? {
components: Components[K]['components'];
components: components[key]['components'];
} : unknown)>;
}, ', '>})${Array}`;
} & (IsNarrowable<Name, string> extends true ? {
name: Name;
} : unknown) & (IsNarrowable<Indexed, boolean> extends true ? {
indexed: Indexed;
} : unknown)> : `${TAbiParameter['type']}${TAbiParameter extends {
}, ', '>})${array}`;
} & (IsNarrowable<name, string> extends true ? {
name: name;
} : unknown) & (IsNarrowable<indexed, boolean> extends true ? {
indexed: indexed;
} : unknown)> : `${abiParameter['type']}${abiParameter extends {
indexed: true;
} ? ' indexed' : ''}${TAbiParameter['name'] extends infer Name extends string ? Name extends '' ? '' : ` ${AssertName<Name>}` : ''}`;
} ? ' indexed' : ''}${abiParameter['name'] extends infer name extends string ? name extends '' ? '' : ` ${AssertName<name>}` : ''}`;
/**

@@ -50,3 +50,3 @@ * Formats {@link AbiParameter} to human-readable ABI parameter.

*/
export declare function formatAbiParameter<const TAbiParameter extends AbiParameter | AbiEventParameter>(abiParameter: TAbiParameter): FormatAbiParameter<TAbiParameter>;
export declare function formatAbiParameter<const abiParameter extends AbiParameter | AbiEventParameter>(abiParameter: abiParameter): FormatAbiParameter<abiParameter>;
//# sourceMappingURL=formatAbiParameter.d.ts.map

10

dist/types/human-readable/formatAbiParameters.d.ts

@@ -7,3 +7,3 @@ import type { AbiEventParameter, AbiParameter } from '../abi.js';

*
* @param TAbiParameters - ABI parameters
* @param abiParameters - ABI parameters
* @returns Human-readable ABI parameters

@@ -18,7 +18,7 @@ *

*/
export type FormatAbiParameters<TAbiParameters extends readonly [
export type FormatAbiParameters<abiParameters extends readonly [
AbiParameter | AbiEventParameter,
...(readonly (AbiParameter | AbiEventParameter)[])
]> = Join<{
[K in keyof TAbiParameters]: FormatAbiParameter<TAbiParameters[K]>;
[key in keyof abiParameters]: FormatAbiParameter<abiParameters[key]>;
}, ', '>;

@@ -38,6 +38,6 @@ /**

*/
export declare function formatAbiParameters<const TAbiParameters extends readonly [
export declare function formatAbiParameters<const abiParameters extends readonly [
AbiParameter | AbiEventParameter,
...(readonly (AbiParameter | AbiEventParameter)[])
]>(abiParameters: TAbiParameters): FormatAbiParameters<TAbiParameters>;
]>(abiParameters: abiParameters): FormatAbiParameters<abiParameters>;
//# sourceMappingURL=formatAbiParameters.d.ts.map

10

dist/types/human-readable/parseAbi.d.ts

@@ -9,3 +9,3 @@ import type { Abi } from '../abi.js';

*
* @param TSignatures - Human-readable ABI
* @param signatures - Human-readable ABI
* @returns Parsed {@link Abi}

@@ -22,5 +22,5 @@ *

*/
export type ParseAbi<TSignatures extends readonly string[]> = string[] extends TSignatures ? Abi : TSignatures extends readonly string[] ? TSignatures extends Signatures<TSignatures> ? ParseStructs<TSignatures> extends infer Structs ? {
[K in keyof TSignatures]: TSignatures[K] extends string ? ParseSignature<TSignatures[K], Structs> : never;
} extends infer Mapped extends readonly unknown[] ? Filter<Mapped, never> extends infer Result ? Result extends readonly [] ? never : Result : never : never : never : never : never;
export type ParseAbi<signatures extends readonly string[]> = string[] extends signatures ? Abi : signatures extends readonly string[] ? signatures extends Signatures<signatures> ? ParseStructs<signatures> extends infer sructs ? {
[key in keyof signatures]: signatures[key] extends string ? ParseSignature<signatures[key], sructs> : never;
} extends infer mapped extends readonly unknown[] ? Filter<mapped, never> extends infer result ? result extends readonly [] ? never : result : never : never : never : never : never;
/**

@@ -39,3 +39,3 @@ * Parses human-readable ABI into JSON {@link Abi}

*/
export declare function parseAbi<const TSignatures extends readonly string[]>(signatures: TSignatures['length'] extends 0 ? Error<'At least one signature required'> : Signatures<TSignatures> extends TSignatures ? TSignatures : Signatures<TSignatures>): ParseAbi<TSignatures>;
export declare function parseAbi<const signatures extends readonly string[]>(signatures: signatures['length'] extends 0 ? Error<'At least one signature required'> : Signatures<signatures> extends signatures ? signatures : Signatures<signatures>): ParseAbi<signatures>;
//# sourceMappingURL=parseAbi.d.ts.map

10

dist/types/human-readable/parseAbiItem.d.ts

@@ -10,3 +10,3 @@ import type { Abi } from '../abi.js';

*
* @param TSignature - Human-readable ABI item
* @param signature - Human-readable ABI item
* @returns Parsed {@link Abi} item

@@ -24,5 +24,5 @@ *

*/
export type ParseAbiItem<TSignature extends string | readonly string[] | readonly unknown[]> = (TSignature extends string ? string extends TSignature ? Abi[number] : TSignature extends Signature<TSignature> ? ParseSignature<TSignature> : never : never) | (TSignature extends readonly string[] ? string[] extends TSignature ? Abi[number] : TSignature extends Signatures<TSignature> ? ParseStructs<TSignature> extends infer Structs ? {
[K in keyof TSignature]: ParseSignature<TSignature[K] extends string ? TSignature[K] : never, Structs>;
} extends infer Mapped extends readonly unknown[] ? Filter<Mapped, never>[0] extends infer Result ? Result extends undefined ? never : Result : never : never : never : never : never);
export type ParseAbiItem<signature extends string | readonly string[] | readonly unknown[]> = (signature extends string ? string extends signature ? Abi[number] : signature extends Signature<signature> ? ParseSignature<signature> : never : never) | (signature extends readonly string[] ? string[] extends signature ? Abi[number] : signature extends Signatures<signature> ? ParseStructs<signature> extends infer structs ? {
[key in keyof signature]: ParseSignature<signature[key] extends string ? signature[key] : never, structs>;
} extends infer mapped extends readonly unknown[] ? Filter<mapped, never>[0] extends infer result ? result extends undefined ? never : result : never : never : never : never : never);
/**

@@ -45,3 +45,3 @@ * Parses human-readable ABI item (e.g. error, event, function) into {@link Abi} item

*/
export declare function parseAbiItem<TSignature extends string | readonly string[] | readonly unknown[]>(signature: Narrow<TSignature> & ((TSignature extends string ? string extends TSignature ? unknown : Signature<TSignature> : never) | (TSignature extends readonly string[] ? TSignature extends readonly [] ? Error<'At least one signature required.'> : string[] extends TSignature ? unknown : Signatures<TSignature> : never))): ParseAbiItem<TSignature>;
export declare function parseAbiItem<signature extends string | readonly string[] | readonly unknown[]>(signature: Narrow<signature> & ((signature extends string ? string extends signature ? unknown : Signature<signature> : never) | (signature extends readonly string[] ? signature extends readonly [] ? Error<'At least one signature required.'> : string[] extends signature ? unknown : Signatures<signature> : never))): ParseAbiItem<signature>;
//# sourceMappingURL=parseAbiItem.d.ts.map

18

dist/types/human-readable/parseAbiParameter.d.ts

@@ -10,3 +10,3 @@ import type { AbiParameter } from '../abi.js';

*
* @param TParam - Human-readable ABI parameter
* @param param - Human-readable ABI parameter
* @returns Parsed {@link AbiParameter}

@@ -24,10 +24,10 @@ *

*/
export type ParseAbiParameter<TParam extends string | readonly string[] | readonly unknown[]> = (TParam extends string ? TParam extends '' ? never : string extends TParam ? AbiParameter : ParseAbiParameter_<TParam, {
Modifier: Modifier;
}> : never) | (TParam extends readonly string[] ? string[] extends TParam ? AbiParameter : ParseStructs<TParam> extends infer Structs ? {
[K in keyof TParam]: TParam[K] extends string ? IsStructSignature<TParam[K]> extends true ? never : ParseAbiParameter_<TParam[K], {
Modifier: Modifier;
Structs: Structs;
export type ParseAbiParameter<param extends string | readonly string[] | readonly unknown[]> = (param extends string ? param extends '' ? never : string extends param ? AbiParameter : ParseAbiParameter_<param, {
modifier: Modifier;
}> : never) | (param extends readonly string[] ? string[] extends param ? AbiParameter : ParseStructs<param> extends infer structs ? {
[key in keyof param]: param[key] extends string ? IsStructSignature<param[key]> extends true ? never : ParseAbiParameter_<param[key], {
modifier: Modifier;
structs: structs;
}> : never;
} extends infer Mapped extends readonly unknown[] ? Filter<Mapped, never>[0] extends infer Result ? Result extends undefined ? never : Result : never : never : never : never);
} extends infer mapped extends readonly unknown[] ? Filter<mapped, never>[0] extends infer result ? result extends undefined ? never : result : never : never : never : never);
/**

@@ -50,3 +50,3 @@ * Parses human-readable ABI parameter into {@link AbiParameter}

*/
export declare function parseAbiParameter<TParam extends string | readonly string[] | readonly unknown[]>(param: Narrow<TParam> & ((TParam extends string ? TParam extends '' ? Error<'Empty string is not allowed.'> : unknown : never) | (TParam extends readonly string[] ? TParam extends readonly [] ? Error<'At least one parameter required.'> : string[] extends TParam ? unknown : unknown : never))): ParseAbiParameter<TParam>;
export declare function parseAbiParameter<param extends string | readonly string[] | readonly unknown[]>(param: Narrow<param> & ((param extends string ? param extends '' ? Error<'Empty string is not allowed.'> : unknown : never) | (param extends readonly string[] ? param extends readonly [] ? Error<'At least one parameter required.'> : string[] extends param ? unknown : unknown : never))): ParseAbiParameter<param>;
//# sourceMappingURL=parseAbiParameter.d.ts.map

20

dist/types/human-readable/parseAbiParameters.d.ts

@@ -11,3 +11,3 @@ import type { AbiParameter } from '../abi.js';

*
* @param TParams - Human-readable ABI parameters
* @param params - Human-readable ABI parameters
* @returns Parsed {@link AbiParameter}s

@@ -25,10 +25,10 @@ *

*/
export type ParseAbiParameters<TParams extends string | readonly string[] | readonly unknown[]> = (TParams extends string ? TParams extends '' ? never : string extends TParams ? readonly AbiParameter[] : ParseAbiParameters_<SplitParameters<TParams>, {
Modifier: Modifier;
}> : never) | (TParams extends readonly string[] ? string[] extends TParams ? AbiParameter : ParseStructs<TParams> extends infer Structs ? {
[K in keyof TParams]: TParams[K] extends string ? IsStructSignature<TParams[K]> extends true ? never : ParseAbiParameters_<SplitParameters<TParams[K]>, {
Modifier: Modifier;
Structs: Structs;
export type ParseAbiParameters<params extends string | readonly string[] | readonly unknown[]> = (params extends string ? params extends '' ? never : string extends params ? readonly AbiParameter[] : ParseAbiParameters_<SplitParameters<params>, {
modifier: Modifier;
}> : never) | (params extends readonly string[] ? string[] extends params ? AbiParameter : ParseStructs<params> extends infer structs ? {
[key in keyof params]: params[key] extends string ? IsStructSignature<params[key]> extends true ? never : ParseAbiParameters_<SplitParameters<params[key]>, {
modifier: Modifier;
structs: structs;
}> : never;
} extends infer Mapped extends readonly unknown[] ? Filter<Mapped, never> extends readonly [...infer Content] ? Content['length'] extends 0 ? never : DeepFlatten<Content> : never : never : never : never);
} extends infer mapped extends readonly unknown[] ? Filter<mapped, never> extends readonly [...infer content] ? content['length'] extends 0 ? never : DeepFlatten<content> : never : never : never : never);
/**

@@ -45,3 +45,3 @@ * Flatten all members of {@link T}

*/
type DeepFlatten<T extends readonly unknown[], Acc extends readonly unknown[] = readonly []> = T extends readonly [infer Head, ...infer Tail] ? Tail extends undefined ? never : Head extends readonly unknown[] ? DeepFlatten<Tail, readonly [...Acc, ...DeepFlatten<Head>]> : DeepFlatten<Tail, readonly [...Acc, Head]> : Acc;
type DeepFlatten<T extends readonly unknown[], Acc extends readonly unknown[] = readonly []> = T extends readonly [infer head, ...infer tail] ? tail extends undefined ? never : head extends readonly unknown[] ? DeepFlatten<tail, readonly [...Acc, ...DeepFlatten<head>]> : DeepFlatten<tail, readonly [...Acc, head]> : Acc;
/**

@@ -64,4 +64,4 @@ * Parses human-readable ABI parameters into {@link AbiParameter}s

*/
export declare function parseAbiParameters<TParams extends string | readonly string[] | readonly unknown[]>(params: Narrow<TParams> & ((TParams extends string ? TParams extends '' ? Error<'Empty string is not allowed.'> : unknown : never) | (TParams extends readonly string[] ? TParams extends readonly [] ? Error<'At least one parameter required.'> : string[] extends TParams ? unknown : unknown : never))): ParseAbiParameters<TParams>;
export declare function parseAbiParameters<params extends string | readonly string[] | readonly unknown[]>(params: Narrow<params> & ((params extends string ? params extends '' ? Error<'Empty string is not allowed.'> : unknown : never) | (params extends readonly string[] ? params extends readonly [] ? Error<'At least one parameter required.'> : string[] extends params ? unknown : unknown : never))): ParseAbiParameters<params>;
export {};
//# sourceMappingURL=parseAbiParameters.d.ts.map

2

dist/types/human-readable/runtime/signatures.d.ts

@@ -28,3 +28,3 @@ import type { AbiStateMutability } from '../../abi.js';

parameters: string;
stateMutability?: Extract<AbiStateMutability, 'payable'>;
stateMutability?: Extract<AbiStateMutability, "payable">;
} | undefined;

@@ -31,0 +31,0 @@ export declare function isFallbackSignature(signature: string): boolean;

10

dist/types/human-readable/runtime/utils.d.ts

@@ -11,3 +11,3 @@ import type { AbiItemType, AbiType, SolidityArray, SolidityBytes, SolidityString, SolidityTuple } from '../../abi.js';

name?: string | undefined;
internalType?: string | undefined;
internalType?: import("../../abi.js").AbiInternalType | undefined;
} & {

@@ -35,3 +35,3 @@ indexed?: boolean;

name?: string | undefined;
internalType?: string | undefined;
internalType?: import("../../abi.js").AbiInternalType | undefined;
} & {

@@ -62,3 +62,3 @@ indexed?: boolean;

name?: string | undefined;
internalType?: string | undefined;
internalType?: import("../../abi.js").AbiInternalType | undefined;
} & {

@@ -91,3 +91,3 @@ indexed?: boolean;

name?: string | undefined;
internalType?: string | undefined;
internalType?: import("../../abi.js").AbiInternalType | undefined;
} & {

@@ -135,3 +135,3 @@ indexed?: boolean;

name?: string | undefined;
internalType?: string | undefined;
internalType?: import("../../abi.js").AbiInternalType | undefined;
} & {

@@ -138,0 +138,0 @@ indexed?: boolean;

40

dist/types/human-readable/types/signatures.d.ts
import type { AbiStateMutability } from '../../abi.js';
import type { Error } from '../../types.js';
export type ErrorSignature<TName extends string = string, TParameters extends string = string> = `error ${TName}(${TParameters})`;
export type IsErrorSignature<T extends string> = T extends ErrorSignature<infer Name> ? IsName<Name> : false;
export type EventSignature<TName extends string = string, TParameters extends string = string> = `event ${TName}(${TParameters})`;
export type IsEventSignature<T extends string> = T extends EventSignature<infer Name> ? IsName<Name> : false;
export type FunctionSignature<TName extends string = string, TTail extends string = string> = `function ${TName}(${TTail}`;
export type IsFunctionSignature<T> = T extends FunctionSignature<infer Name> ? IsName<Name> extends true ? T extends ValidFunctionSignatures ? true : T extends `function ${string}(${infer Parameters})` ? Parameters extends InvalidFunctionParameters ? false : true : false : false : false;
export type ErrorSignature<name extends string = string, parameters extends string = string> = `error ${name}(${parameters})`;
export type IsErrorSignature<signature extends string> = signature extends ErrorSignature<infer name> ? IsName<name> : false;
export type EventSignature<name extends string = string, parameters extends string = string> = `event ${name}(${parameters})`;
export type IsEventSignature<signature extends string> = signature extends EventSignature<infer name> ? IsName<name> : false;
export type FunctionSignature<name extends string = string, tail extends string = string> = `function ${name}(${tail}`;
export type IsFunctionSignature<signature> = signature extends FunctionSignature<infer name> ? IsName<name> extends true ? signature extends ValidFunctionSignatures ? true : signature extends `function ${string}(${infer parameters})` ? parameters extends InvalidFunctionParameters ? false : true : false : false : false;
export type Scope = 'public' | 'external';
type Returns = `returns (${string})` | `returns(${string})`;
type ValidFunctionSignatures = `function ${string}()` | `function ${string}() ${Returns}` | `function ${string}() ${AbiStateMutability}` | `function ${string}() ${Scope}` | `function ${string}() ${AbiStateMutability} ${Returns}` | `function ${string}() ${Scope} ${Returns}` | `function ${string}() ${Scope} ${AbiStateMutability}` | `function ${string}() ${Scope} ${AbiStateMutability} ${Returns}` | `function ${string}(${string}) ${Returns}` | `function ${string}(${string}) ${AbiStateMutability}` | `function ${string}(${string}) ${Scope}` | `function ${string}(${string}) ${AbiStateMutability} ${Returns}` | `function ${string}(${string}) ${Scope} ${Returns}` | `function ${string}(${string}) ${Scope} ${AbiStateMutability}` | `function ${string}(${string}) ${Scope} ${AbiStateMutability} ${Returns}`;
export type StructSignature<TName extends string = string, TProperties extends string = string> = `struct ${TName} {${TProperties}}`;
export type IsStructSignature<T extends string> = T extends StructSignature<infer Name> ? IsName<Name> : false;
type ConstructorSignature<TTail extends string = string> = `constructor(${TTail}`;
export type IsConstructorSignature<T> = T extends ConstructorSignature ? T extends ValidConstructorSignatures ? true : false : false;
export type StructSignature<name extends string = string, properties extends string = string> = `struct ${name} {${properties}}`;
export type IsStructSignature<signature extends string> = signature extends StructSignature<infer name> ? IsName<name> : false;
type ConstructorSignature<tail extends string = string> = `constructor(${tail}`;
export type IsConstructorSignature<signature> = signature extends ConstructorSignature ? signature extends ValidConstructorSignatures ? true : false : false;
type ValidConstructorSignatures = `constructor(${string})` | `constructor(${string}) payable`;
export type FallbackSignature<TAbiStateMutability extends '' | ' payable' = ''> = `fallback() external${TAbiStateMutability}`;
export type FallbackSignature<abiStateMutability extends '' | ' payable' = ''> = `fallback() external${abiStateMutability}`;
export type ReceiveSignature = 'receive() external payable';
export type IsSignature<T extends string> = (IsErrorSignature<T> extends true ? true : never) | (IsEventSignature<T> extends true ? true : never) | (IsFunctionSignature<T> extends true ? true : never) | (IsStructSignature<T> extends true ? true : never) | (IsConstructorSignature<T> extends true ? true : never) | (T extends FallbackSignature ? true : never) | (T extends ReceiveSignature ? true : never) extends infer Condition ? [Condition] extends [never] ? false : true : false;
export type Signature<T extends string, K extends string | unknown = unknown> = IsSignature<T> extends true ? T : string extends T ? T : Error<`Signature "${T}" is invalid${K extends string ? ` at position ${K}` : ''}.`>;
export type Signatures<T extends readonly string[]> = {
[K in keyof T]: Signature<T[K], K>;
export type IsSignature<type extends string> = (IsErrorSignature<type> extends true ? true : never) | (IsEventSignature<type> extends true ? true : never) | (IsFunctionSignature<type> extends true ? true : never) | (IsStructSignature<type> extends true ? true : never) | (IsConstructorSignature<type> extends true ? true : never) | (type extends FallbackSignature ? true : never) | (type extends ReceiveSignature ? true : never) extends infer condition ? [condition] extends [never] ? false : true : false;
export type Signature<string1 extends string, string2 extends string | unknown = unknown> = IsSignature<string1> extends true ? string1 : string extends string1 ? string1 : Error<`Signature "${string1}" is invalid${string2 extends string ? ` at position ${string2}` : ''}.`>;
export type Signatures<signatures extends readonly string[]> = {
[key in keyof signatures]: Signature<signatures[key], key>;
};

@@ -27,8 +27,8 @@ export type Modifier = 'calldata' | 'indexed' | 'memory' | 'storage';

export type EventModifier = Extract<Modifier, 'indexed'>;
export type IsName<TName extends string> = TName extends '' ? false : ValidateName<TName> extends TName ? true : false;
export type AssertName<TName extends string> = ValidateName<TName> extends infer InvalidName extends string[] ? `[${InvalidName[number]}]` : TName;
export type ValidateName<TName extends string, CheckCharacters extends boolean = false> = TName extends `${string}${' '}${string}` ? Error<`Identifier "${TName}" cannot contain whitespace.`> : IsSolidityKeyword<TName> extends true ? Error<`"${TName}" is a protected Solidity keyword.`> : TName extends `${number}` ? Error<`Identifier "${TName}" cannot be a number string.`> : TName extends `${number}${string}` ? Error<`Identifier "${TName}" cannot start with a number.`> : CheckCharacters extends true ? IsValidCharacter<TName> extends true ? TName : Error<`"${TName}" contains invalid character.`> : TName;
export type IsSolidityKeyword<T extends string> = T extends SolidityKeywords ? true : false;
export type IsName<name extends string> = name extends '' ? false : ValidateName<name> extends name ? true : false;
export type AssertName<name extends string> = ValidateName<name> extends infer invalidName extends string[] ? `[${invalidName[number]}]` : name;
export type ValidateName<name extends string, checkCharacters extends boolean = false> = name extends `${string}${' '}${string}` ? Error<`Identifier "${name}" cannot contain whitespace.`> : IsSolidityKeyword<name> extends true ? Error<`"${name}" is a protected Solidity keyword.`> : name extends `${number}` ? Error<`Identifier "${name}" cannot be a number string.`> : name extends `${number}${string}` ? Error<`Identifier "${name}" cannot start with a number.`> : checkCharacters extends true ? IsValidCharacter<name> extends true ? name : Error<`"${name}" contains invalid character.`> : name;
export type IsSolidityKeyword<type extends string> = type extends SolidityKeywords ? true : false;
export type SolidityKeywords = 'after' | 'alias' | 'anonymous' | 'apply' | 'auto' | 'byte' | 'calldata' | 'case' | 'catch' | 'constant' | 'copyof' | 'default' | 'defined' | 'error' | 'event' | 'external' | 'false' | 'final' | 'function' | 'immutable' | 'implements' | 'in' | 'indexed' | 'inline' | 'internal' | 'let' | 'mapping' | 'match' | 'memory' | 'mutable' | 'null' | 'of' | 'override' | 'partial' | 'private' | 'promise' | 'public' | 'pure' | 'reference' | 'relocatable' | 'return' | 'returns' | 'sizeof' | 'static' | 'storage' | 'struct' | 'super' | 'supports' | 'switch' | 'this' | 'true' | 'try' | 'typedef' | 'typeof' | 'var' | 'view' | 'virtual' | `address${`[${string}]` | ''}` | `bool${`[${string}]` | ''}` | `string${`[${string}]` | ''}` | `tuple${`[${string}]` | ''}` | `bytes${number | ''}${`[${string}]` | ''}` | `${'u' | ''}int${number | ''}${`[${string}]` | ''}`;
export type IsValidCharacter<T extends string> = T extends `${ValidCharacters}${infer Tail}` ? Tail extends '' ? true : IsValidCharacter<Tail> : false;
export type IsValidCharacter<character extends string> = character extends `${ValidCharacters}${infer tail}` ? tail extends '' ? true : IsValidCharacter<tail> : false;
type ValidCharacters = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '_' | '$';

@@ -35,0 +35,0 @@ type InvalidFunctionParameters = `${string}${MangledReturns} (${string}` | `${string}) ${MangledReturns}${string}` | `${string})${string}${MangledReturns}${string}(${string}`;

52

dist/types/human-readable/types/structs.d.ts

@@ -6,44 +6,44 @@ import type { AbiParameter } from '../../abi.js';

export type StructLookup = Record<string, readonly AbiParameter[]>;
export type ParseStructs<TSignatures extends readonly string[]> = {
[Signature in TSignatures[number] as ParseStruct<Signature> extends infer Struct extends {
export type ParseStructs<signatures extends readonly string[]> = {
[signature in signatures[number] as ParseStruct<signature> extends infer struct extends {
name: string;
} ? Struct['name'] : never]: ParseStruct<Signature>['components'];
} extends infer Structs extends Record<string, readonly (AbiParameter & {
} ? struct['name'] : never]: ParseStruct<signature>['components'];
} extends infer structs extends Record<string, readonly (AbiParameter & {
type: string;
})[]> ? {
[StructName in keyof Structs]: ResolveStructs<Structs[StructName], Structs>;
[structName in keyof structs]: ResolveStructs<structs[structName], structs>;
} : never;
export type ParseStruct<TSignature extends string, TStructs extends StructLookup | unknown = unknown> = TSignature extends StructSignature<infer Name, infer Properties> ? {
readonly name: Trim<Name>;
readonly components: ParseStructProperties<Properties, TStructs>;
export type ParseStruct<signature extends string, structs extends StructLookup | unknown = unknown> = signature extends StructSignature<infer name, infer properties> ? {
readonly name: Trim<name>;
readonly components: ParseStructProperties<properties, structs>;
} : never;
export type ResolveStructs<TAbiParameters extends readonly (AbiParameter & {
export type ResolveStructs<abiParameters extends readonly (AbiParameter & {
type: string;
})[], TStructs extends Record<string, readonly (AbiParameter & {
})[], structs extends Record<string, readonly (AbiParameter & {
type: string;
})[]>, TKeyReferences extends {
})[]>, keyReferences extends {
[_: string]: unknown;
} | unknown = unknown> = readonly [
...{
[K in keyof TAbiParameters]: TAbiParameters[K]['type'] extends `${infer Head extends string & keyof TStructs}[${infer Tail}]` ? Head extends keyof TKeyReferences ? Error<`Circular reference detected. Struct "${TAbiParameters[K]['type']}" is a circular reference.`> : {
readonly name: TAbiParameters[K]['name'];
readonly type: `tuple[${Tail}]`;
readonly components: ResolveStructs<TStructs[Head], TStructs, TKeyReferences & {
[_ in Head]: true;
[key in keyof abiParameters]: abiParameters[key]['type'] extends `${infer head extends string & keyof structs}[${infer tail}]` ? head extends keyof keyReferences ? Error<`Circular reference detected. Struct "${abiParameters[key]['type']}" is a circular reference.`> : {
readonly name: abiParameters[key]['name'];
readonly type: `tuple[${tail}]`;
readonly components: ResolveStructs<structs[head], structs, keyReferences & {
[_ in head]: true;
}>;
} : TAbiParameters[K]['type'] extends keyof TStructs ? TAbiParameters[K]['type'] extends keyof TKeyReferences ? Error<`Circular reference detected. Struct "${TAbiParameters[K]['type']}" is a circular reference.`> : {
readonly name: TAbiParameters[K]['name'];
} : abiParameters[key]['type'] extends keyof structs ? abiParameters[key]['type'] extends keyof keyReferences ? Error<`Circular reference detected. Struct "${abiParameters[key]['type']}" is a circular reference.`> : {
readonly name: abiParameters[key]['name'];
readonly type: 'tuple';
readonly components: ResolveStructs<TStructs[TAbiParameters[K]['type']], TStructs, TKeyReferences & {
[_ in TAbiParameters[K]['type']]: true;
readonly components: ResolveStructs<structs[abiParameters[key]['type']], structs, keyReferences & {
[_ in abiParameters[key]['type']]: true;
}>;
} : TAbiParameters[K];
} : abiParameters[key];
}
];
export type ParseStructProperties<T extends string, TStructs extends StructLookup | unknown = unknown, Result extends any[] = []> = Trim<T> extends `${infer Head};${infer Tail}` ? ParseStructProperties<Tail, TStructs, [
...Result,
ParseAbiParameter<Head, {
Structs: TStructs;
export type ParseStructProperties<signature extends string, structs extends StructLookup | unknown = unknown, result extends any[] = []> = Trim<signature> extends `${infer head};${infer tail}` ? ParseStructProperties<tail, structs, [
...result,
ParseAbiParameter<head, {
structs: structs;
}>
]> : Result;
]> : result;
//# sourceMappingURL=structs.d.ts.map

192

dist/types/human-readable/types/utils.d.ts

@@ -6,37 +6,37 @@ import type { AbiParameter, AbiStateMutability, AbiType, SolidityFixedArrayRange } from '../../abi.js';

import type { StructLookup } from './structs.js';
export type ParseSignature<TSignature extends string, TStructs extends StructLookup | unknown = unknown> = (IsErrorSignature<TSignature> extends true ? TSignature extends ErrorSignature<infer Name, infer Parameters> ? {
readonly name: Name;
export type ParseSignature<signature extends string, structs extends StructLookup | unknown = unknown> = (IsErrorSignature<signature> extends true ? signature extends ErrorSignature<infer name, infer parameters> ? {
readonly name: name;
readonly type: 'error';
readonly inputs: ParseAbiParameters<SplitParameters<Parameters>, {
Structs: TStructs;
readonly inputs: ParseAbiParameters<SplitParameters<parameters>, {
structs: structs;
}>;
} : never : never) | (IsEventSignature<TSignature> extends true ? TSignature extends EventSignature<infer Name, infer Parameters> ? {
readonly name: Name;
} : never : never) | (IsEventSignature<signature> extends true ? signature extends EventSignature<infer name, infer parameters> ? {
readonly name: name;
readonly type: 'event';
readonly inputs: ParseAbiParameters<SplitParameters<Parameters>, {
Modifier: EventModifier;
Structs: TStructs;
readonly inputs: ParseAbiParameters<SplitParameters<parameters>, {
modifier: EventModifier;
structs: structs;
}>;
} : never : never) | (IsFunctionSignature<TSignature> extends true ? TSignature extends FunctionSignature<infer Name, infer Tail> ? {
readonly name: Name;
} : never : never) | (IsFunctionSignature<signature> extends true ? signature extends FunctionSignature<infer name, infer tail> ? {
readonly name: name;
readonly type: 'function';
readonly stateMutability: _ParseFunctionParametersAndStateMutability<TSignature>['StateMutability'];
readonly inputs: ParseAbiParameters<SplitParameters<_ParseFunctionParametersAndStateMutability<TSignature>['Inputs']>, {
Modifier: FunctionModifier;
Structs: TStructs;
readonly stateMutability: _ParseFunctionParametersAndStateMutability<signature>['StateMutability'];
readonly inputs: ParseAbiParameters<SplitParameters<_ParseFunctionParametersAndStateMutability<signature>['Inputs']>, {
modifier: FunctionModifier;
structs: structs;
}>;
readonly outputs: Tail extends `${string}returns (${infer Returns})` | `${string}returns(${infer Returns})` ? ParseAbiParameters<SplitParameters<Returns>, {
Modifier: FunctionModifier;
Structs: TStructs;
readonly outputs: tail extends `${string}returns (${infer returns})` | `${string}returns(${infer returns})` ? ParseAbiParameters<SplitParameters<returns>, {
modifier: FunctionModifier;
structs: structs;
}> : readonly [];
} : never : never) | (IsConstructorSignature<TSignature> extends true ? {
} : never : never) | (IsConstructorSignature<signature> extends true ? {
readonly type: 'constructor';
readonly stateMutability: _ParseConstructorParametersAndStateMutability<TSignature>['StateMutability'];
readonly inputs: ParseAbiParameters<SplitParameters<_ParseConstructorParametersAndStateMutability<TSignature>['Inputs']>, {
Structs: TStructs;
readonly stateMutability: _ParseConstructorParametersAndStateMutability<signature>['StateMutability'];
readonly inputs: ParseAbiParameters<SplitParameters<_ParseConstructorParametersAndStateMutability<signature>['Inputs']>, {
structs: structs;
}>;
} : never) | (TSignature extends FallbackSignature<infer StateMutability> ? {
} : never) | (signature extends FallbackSignature<infer stateMutability> ? {
readonly type: 'fallback';
readonly stateMutability: StateMutability extends `${string}payable` ? 'payable' : 'nonpayable';
} : never) | (TSignature extends ReceiveSignature ? {
readonly stateMutability: stateMutability extends `${string}payable` ? 'payable' : 'nonpayable';
} : never) | (signature extends ReceiveSignature ? {
readonly type: 'receive';

@@ -46,111 +46,111 @@ readonly stateMutability: 'payable';

type ParseOptions = {
Modifier?: Modifier;
Structs?: StructLookup | unknown;
modifier?: Modifier;
structs?: StructLookup | unknown;
};
type DefaultParseOptions = object;
export type ParseAbiParameters<T extends readonly string[], Options extends ParseOptions = DefaultParseOptions> = T extends [''] ? readonly [] : readonly [
export type ParseAbiParameters<signatures extends readonly string[], options extends ParseOptions = DefaultParseOptions> = signatures extends [''] ? readonly [] : readonly [
...{
[K in keyof T]: ParseAbiParameter<T[K], Options>;
[key in keyof signatures]: ParseAbiParameter<signatures[key], options>;
}
];
export type ParseAbiParameter<T extends string, Options extends ParseOptions = DefaultParseOptions> = (T extends `(${string})${string}` ? _ParseTuple<T, Options> : T extends `${infer Type} ${infer Tail}` ? Trim<Tail> extends infer Trimmed extends string ? // TODO: data location modifiers only allowed for struct/array types
export type ParseAbiParameter<signature extends string, options extends ParseOptions = DefaultParseOptions> = (signature extends `(${string})${string}` ? _ParseTuple<signature, options> : signature extends `${infer type} ${infer tail}` ? Trim<tail> extends infer trimmed extends string ? // TODO: data location modifiers only allowed for struct/array types
{
readonly type: Trim<Type>;
} & _SplitNameOrModifier<Trimmed, Options> : never : {
readonly type: T;
}) extends infer ShallowParameter extends AbiParameter & {
readonly type: Trim<type>;
} & _SplitNameOrModifier<trimmed, options> : never : {
readonly type: signature;
}) extends infer shallowParameter extends AbiParameter & {
type: string;
indexed?: boolean;
} ? (ShallowParameter['type'] extends keyof Options['Structs'] ? {
} ? (shallowParameter['type'] extends keyof options['structs'] ? {
readonly type: 'tuple';
readonly components: Options['Structs'][ShallowParameter['type']];
} & (IsUnknown<ShallowParameter['name']> extends false ? {
readonly name: ShallowParameter['name'];
} : object) & (ShallowParameter['indexed'] extends true ? {
readonly components: options['structs'][shallowParameter['type']];
} & (IsUnknown<shallowParameter['name']> extends false ? {
readonly name: shallowParameter['name'];
} : object) & (shallowParameter['indexed'] extends true ? {
readonly indexed: true;
} : object) : ShallowParameter['type'] extends `${infer Type extends string & keyof Options['Structs']}[${infer Tail}]` ? {
readonly type: `tuple[${Tail}]`;
readonly components: Options['Structs'][Type];
} & (IsUnknown<ShallowParameter['name']> extends false ? {
readonly name: ShallowParameter['name'];
} : object) & (ShallowParameter['indexed'] extends true ? {
} : object) : shallowParameter['type'] extends `${infer type extends string & keyof options['structs']}[${infer tail}]` ? {
readonly type: `tuple[${tail}]`;
readonly components: options['structs'][type];
} & (IsUnknown<shallowParameter['name']> extends false ? {
readonly name: shallowParameter['name'];
} : object) & (shallowParameter['indexed'] extends true ? {
readonly indexed: true;
} : object) : ShallowParameter) extends infer Parameter extends AbiParameter & {
} : object) : shallowParameter) extends infer Parameter extends AbiParameter & {
type: string;
indexed?: boolean;
} ? Pretty<_ValidateAbiParameter<Parameter>> : never : never;
export type SplitParameters<T extends string, Result extends unknown[] = [], Current extends string = '', Depth extends readonly number[] = []> = T extends '' ? Current extends '' ? [...Result] : Depth['length'] extends 0 ? [...Result, Trim<Current>] : Error<`Unbalanced parentheses. "${Current}" has too many opening parentheses.`> : T extends `${infer Char}${infer Tail}` ? Char extends ',' ? Depth['length'] extends 0 ? SplitParameters<Tail, [...Result, Trim<Current>], ''> : SplitParameters<Tail, Result, `${Current}${Char}`, Depth> : Char extends '(' ? SplitParameters<Tail, Result, `${Current}${Char}`, [...Depth, 1]> : Char extends ')' ? Depth['length'] extends 0 ? Error<`Unbalanced parentheses. "${Current}" has too many closing parentheses.`> : SplitParameters<Tail, Result, `${Current}${Char}`, Pop<Depth>> : SplitParameters<Tail, Result, `${Current}${Char}`, Depth> : [];
type Pop<T extends readonly number[]> = T extends [...infer R, any] ? R : [];
export type _ValidateAbiParameter<TAbiParameter extends AbiParameter> = (TAbiParameter extends {
export type SplitParameters<signature extends string, result extends unknown[] = [], current extends string = '', depth extends readonly number[] = []> = signature extends '' ? current extends '' ? [...result] : depth['length'] extends 0 ? [...result, Trim<current>] : Error<`Unbalanced parentheses. "${current}" has too many opening parentheses.`> : signature extends `${infer char}${infer tail}` ? char extends ',' ? depth['length'] extends 0 ? SplitParameters<tail, [...result, Trim<current>], ''> : SplitParameters<tail, result, `${current}${char}`, depth> : char extends '(' ? SplitParameters<tail, result, `${current}${char}`, [...depth, 1]> : char extends ')' ? depth['length'] extends 0 ? Error<`Unbalanced parentheses. "${current}" has too many closing parentheses.`> : SplitParameters<tail, result, `${current}${char}`, Pop<depth>> : SplitParameters<tail, result, `${current}${char}`, depth> : [];
type Pop<type extends readonly number[]> = type extends [...infer head, any] ? head : [];
export type _ValidateAbiParameter<abiParameter extends AbiParameter> = (abiParameter extends {
name: string;
} ? ValidateName<TAbiParameter['name']> extends infer Name ? Name extends TAbiParameter['name'] ? TAbiParameter : Merge<TAbiParameter, {
readonly name: Name;
}> : never : TAbiParameter) extends infer Parameter ? (ResolvedRegister['StrictAbiType'] extends true ? Parameter extends {
} ? ValidateName<abiParameter['name']> extends infer name ? name extends abiParameter['name'] ? abiParameter : Merge<abiParameter, {
readonly name: name;
}> : never : abiParameter) extends infer parameter ? (ResolvedRegister['strictAbiType'] extends true ? parameter extends {
type: AbiType;
} ? Parameter : Merge<Parameter, {
readonly type: Error<`Type "${Parameter extends {
} ? parameter : Merge<parameter, {
readonly type: Error<`Type "${parameter extends {
type: string;
} ? Parameter['type'] : string}" is not a valid ABI type.`>;
}> : Parameter) extends infer Parameter2 extends {
} ? parameter['type'] : string}" is not a valid ABI type.`>;
}> : parameter) extends infer parameter2 extends {
type: unknown;
} ? Parameter2['type'] extends `${infer Prefix extends 'u' | ''}int${infer Suffix extends `[${string}]` | ''}` ? Pretty<Merge<Parameter2, {
readonly type: `${Prefix}int256${Suffix}`;
}>> : Parameter2 : never : never;
export type _ParseFunctionParametersAndStateMutability<TSignature extends string> = TSignature extends `${infer Head}returns (${string})` | `${infer Head}returns(${string})` ? _ParseFunctionParametersAndStateMutability<Trim<Head>> : TSignature extends `function ${string}(${infer Parameters})` ? {
Inputs: Parameters;
} ? parameter2['type'] extends `${infer prefix extends 'u' | ''}int${infer suffix extends `[${string}]` | ''}` ? Pretty<Merge<parameter2, {
readonly type: `${prefix}int256${suffix}`;
}>> : parameter2 : never : never;
export type _ParseFunctionParametersAndStateMutability<signature extends string> = signature extends `${infer head}returns (${string})` | `${infer head}returns(${string})` ? _ParseFunctionParametersAndStateMutability<Trim<head>> : signature extends `function ${string}(${infer parameters})` ? {
Inputs: parameters;
StateMutability: 'nonpayable';
} : TSignature extends `function ${string}(${infer Parameters}) ${infer ScopeOrStateMutability extends Scope | AbiStateMutability | `${Scope} ${AbiStateMutability}`}` ? {
Inputs: Parameters;
StateMutability: ScopeOrStateMutability extends `${Scope} ${infer StateMutability extends AbiStateMutability}` ? StateMutability : ScopeOrStateMutability extends AbiStateMutability ? ScopeOrStateMutability : 'nonpayable';
} : signature extends `function ${string}(${infer parameters}) ${infer scopeOrStateMutability extends Scope | AbiStateMutability | `${Scope} ${AbiStateMutability}`}` ? {
Inputs: parameters;
StateMutability: scopeOrStateMutability extends `${Scope} ${infer stateMutability extends AbiStateMutability}` ? stateMutability : scopeOrStateMutability extends AbiStateMutability ? scopeOrStateMutability : 'nonpayable';
} : never;
type _ParseConstructorParametersAndStateMutability<TSignature extends string> = TSignature extends `constructor(${infer Parameters}) payable` ? {
Inputs: Parameters;
type _ParseConstructorParametersAndStateMutability<signature extends string> = signature extends `constructor(${infer parameters}) payable` ? {
Inputs: parameters;
StateMutability: 'payable';
} : TSignature extends `constructor(${infer Parameters})` ? {
Inputs: Parameters;
} : signature extends `constructor(${infer parameters})` ? {
Inputs: parameters;
StateMutability: 'nonpayable';
} : never;
export type _ParseTuple<T extends `(${string})${string}`, Options extends ParseOptions = DefaultParseOptions> = T extends `(${infer Parameters})` ? {
export type _ParseTuple<signature extends `(${string})${string}`, options extends ParseOptions = DefaultParseOptions> = signature extends `(${infer parameters})` ? {
readonly type: 'tuple';
readonly components: ParseAbiParameters<SplitParameters<Parameters>, Omit<Options, 'Modifier'>>;
} : T extends `(${infer Head})[${'' | `${SolidityFixedArrayRange}`}]` ? T extends `(${Head})[${infer Size}]` ? {
readonly type: `tuple[${Size}]`;
readonly components: ParseAbiParameters<SplitParameters<Head>, Omit<Options, 'Modifier'>>;
} : never : T extends `(${infer Parameters})[${'' | `${SolidityFixedArrayRange}`}] ${infer NameOrModifier}` ? T extends `(${Parameters})[${infer Size}] ${NameOrModifier}` ? NameOrModifier extends `${string}) ${string}` ? _UnwrapNameOrModifier<NameOrModifier> extends infer Parts extends {
NameOrModifier: string;
readonly components: ParseAbiParameters<SplitParameters<parameters>, Omit<options, 'modifier'>>;
} : signature extends `(${infer head})[${'' | `${SolidityFixedArrayRange}`}]` ? signature extends `(${head})[${infer size}]` ? {
readonly type: `tuple[${size}]`;
readonly components: ParseAbiParameters<SplitParameters<head>, Omit<options, 'modifier'>>;
} : never : signature extends `(${infer parameters})[${'' | `${SolidityFixedArrayRange}`}] ${infer nameOrModifier}` ? signature extends `(${parameters})[${infer size}] ${nameOrModifier}` ? nameOrModifier extends `${string}) ${string}` ? _UnwrapNameOrModifier<nameOrModifier> extends infer parts extends {
nameOrModifier: string;
End: string;
} ? {
readonly type: 'tuple';
readonly components: ParseAbiParameters<SplitParameters<`${Parameters})[${Size}] ${Parts['End']}`>, Omit<Options, 'Modifier'>>;
} & _SplitNameOrModifier<Parts['NameOrModifier'], Options> : never : {
readonly type: `tuple[${Size}]`;
readonly components: ParseAbiParameters<SplitParameters<Parameters>, Omit<Options, 'Modifier'>>;
} & _SplitNameOrModifier<NameOrModifier, Options> : never : T extends `(${infer Parameters}) ${infer NameOrModifier}` ? NameOrModifier extends `${string}) ${string}` ? _UnwrapNameOrModifier<NameOrModifier> extends infer Parts extends {
NameOrModifier: string;
readonly components: ParseAbiParameters<SplitParameters<`${parameters})[${size}] ${parts['End']}`>, Omit<options, 'modifier'>>;
} & _SplitNameOrModifier<parts['nameOrModifier'], options> : never : {
readonly type: `tuple[${size}]`;
readonly components: ParseAbiParameters<SplitParameters<parameters>, Omit<options, 'modifier'>>;
} & _SplitNameOrModifier<nameOrModifier, options> : never : signature extends `(${infer parameters}) ${infer nameOrModifier}` ? nameOrModifier extends `${string}) ${string}` ? _UnwrapNameOrModifier<nameOrModifier> extends infer parts extends {
nameOrModifier: string;
End: string;
} ? {
readonly type: 'tuple';
readonly components: ParseAbiParameters<SplitParameters<`${Parameters}) ${Parts['End']}`>, Omit<Options, 'Modifier'>>;
} & _SplitNameOrModifier<Parts['NameOrModifier'], Options> : never : {
readonly components: ParseAbiParameters<SplitParameters<`${parameters}) ${parts['End']}`>, Omit<options, 'modifier'>>;
} & _SplitNameOrModifier<parts['nameOrModifier'], options> : never : {
readonly type: 'tuple';
readonly components: ParseAbiParameters<SplitParameters<Parameters>, Omit<Options, 'Modifier'>>;
} & _SplitNameOrModifier<NameOrModifier, Options> : never;
export type _SplitNameOrModifier<T extends string, Options extends ParseOptions = DefaultParseOptions> = Trim<T> extends infer Trimmed ? Options extends {
Modifier: Modifier;
} ? Trimmed extends `${infer Mod extends Options['Modifier']} ${infer Name}` ? Pretty<{
readonly name: Trim<Name>;
} & (Mod extends 'indexed' ? {
readonly components: ParseAbiParameters<SplitParameters<parameters>, Omit<options, 'modifier'>>;
} & _SplitNameOrModifier<nameOrModifier, options> : never;
export type _SplitNameOrModifier<signature extends string, options extends ParseOptions = DefaultParseOptions> = Trim<signature> extends infer trimmed ? options extends {
modifier: Modifier;
} ? trimmed extends `${infer mod extends options['modifier']} ${infer name}` ? Pretty<{
readonly name: Trim<name>;
} & (mod extends 'indexed' ? {
readonly indexed: true;
} : object)> : Trimmed extends Options['Modifier'] ? Trimmed extends 'indexed' ? {
} : object)> : trimmed extends options['modifier'] ? trimmed extends 'indexed' ? {
readonly indexed: true;
} : object : {
readonly name: Trimmed;
readonly name: trimmed;
} : {
readonly name: Trimmed;
readonly name: trimmed;
} : never;
export type _UnwrapNameOrModifier<T extends string, Current extends string = ''> = T extends `${infer Head}) ${infer Tail}` ? _UnwrapNameOrModifier<Tail, `${Current}${Current extends '' ? '' : ') '}${Head}`> : {
End: Trim<Current>;
NameOrModifier: Trim<T>;
export type _UnwrapNameOrModifier<signature extends string, current extends string = ''> = signature extends `${infer head}) ${infer tail}` ? _UnwrapNameOrModifier<tail, `${current}${current extends '' ? '' : ') '}${head}`> : {
End: Trim<current>;
nameOrModifier: Trim<signature>;
};
export {};
//# sourceMappingURL=utils.d.ts.map

8

dist/types/narrow.d.ts

@@ -5,3 +5,3 @@ /**

* @param T - Type to infer
* @returns Embedded type of {@link TType}
* @returns Embedded type of {@link type}
*

@@ -11,4 +11,4 @@ * @example

*/
export 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]>;
export 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]>;
};

@@ -25,3 +25,3 @@ /**

*/
export declare function narrow<TType>(value: Narrow<TType>): Narrow<TType>;
export declare function narrow<type>(value: Narrow<type>): Narrow<type>;
//# sourceMappingURL=narrow.d.ts.map

2

dist/types/regex.d.ts

@@ -1,2 +0,2 @@

export declare function execTyped<T>(regex: RegExp, string: string): T | undefined;
export declare function execTyped<type>(regex: RegExp, string: string): type | undefined;
export declare const bytesRegex: RegExp;

@@ -3,0 +3,0 @@ export declare const integerRegex: RegExp;

105

dist/types/register.d.ts

@@ -1,2 +0,3 @@

export type Register = {};
export interface Register {
}
export type ResolvedRegister = {

@@ -7,5 +8,7 @@ /**

*/
AddressType: Register extends {
addressType: Register extends {
addressType: infer type;
} ? type : Register extends {
AddressType: infer type;
} ? type : DefaultRegister['AddressType'];
} ? type : DefaultRegister['addressType'];
/**

@@ -15,5 +18,7 @@ * TypeScript type to use for `int<M>` and `uint<M>` values, where `M > 48`

*/
BigIntType: Register extends {
bigIntType: Register extends {
bigIntType: infer type;
} ? type : Register extends {
BigIntType: infer type;
} ? type : DefaultRegister['BigIntType'];
} ? type : DefaultRegister['bigIntType'];
/**

@@ -23,3 +28,8 @@ * TypeScript type to use for `bytes` values

*/
BytesType: Register extends {
bytesType: Register extends {
bytesType: infer type extends {
inputs: unknown;
outputs: unknown;
};
} ? type : Register extends {
BytesType: infer type extends {

@@ -29,3 +39,3 @@ inputs: unknown;

};
} ? type : DefaultRegister['BytesType'];
} ? type : DefaultRegister['bytesType'];
/**

@@ -35,5 +45,7 @@ * TypeScript type to use for `int<M>` and `uint<M>` values, where `M <= 48`

*/
IntType: Register extends {
intType: Register extends {
intType: infer type;
} ? type : Register extends {
IntType: infer type;
} ? type : DefaultRegister['IntType'];
} ? type : DefaultRegister['intType'];
/**

@@ -47,5 +59,7 @@ * Maximum depth for nested array types (e.g. string[][])

*/
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'];
/**

@@ -55,5 +69,7 @@ * Lower bound for fixed array length

*/
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'];
/**

@@ -63,5 +79,7 @@ * Upper bound for fixed array length

*/
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'];
/**

@@ -75,17 +93,35 @@ * When set, validates {@link AbiParameter}'s `type` against {@link AbiType}

*/
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'];
};
export 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 */

@@ -97,8 +133,27 @@ inputs: `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'];
};
//# sourceMappingURL=register.d.ts.map

95

dist/types/types.d.ts
/**
* Prints custom error message
*
* @param T - Error message
* @param messages - Error message
* @returns Custom error message

@@ -11,12 +11,12 @@ *

*/
export type Error<T extends string | string[]> = T extends string ? [
`Error: ${T}`
export type Error<messages extends string | string[]> = messages extends string ? [
`Error: ${messages}`
] : {
[K in keyof T]: T[K] extends infer Message extends string ? `Error: ${Message}` : never;
[key in keyof messages]: messages[key] extends infer message extends string ? `Error: ${message}` : never;
};
/**
* Filters out all members of {@link T} that are {@link P}
* Filters out all members of {@link items} that are {@link item}
*
* @param T - Items to filter
* @param P - Type to filter out
* @param items - Items to filter
* @param item - Type to filter out
* @returns Filtered items

@@ -28,8 +28,11 @@ *

*/
export type Filter<T extends readonly unknown[], U, Acc extends readonly unknown[] = []> = T extends readonly [infer F, ...infer Rest extends readonly unknown[]] ? [F] extends [U] ? Filter<Rest, U, Acc> : Filter<Rest, U, [...Acc, F]> : readonly [...Acc];
export type Filter<items extends readonly unknown[], item, acc extends readonly unknown[] = []> = items extends readonly [
infer head,
...infer tail extends readonly unknown[]
] ? [head] extends [item] ? Filter<tail, item, acc> : Filter<tail, item, [...acc, head]> : readonly [...acc];
/**
* Checks if {@link T} can be narrowed further than {@link U}
* Checks if {@link type} can be narrowed further than {@link type2}
*
* @param T - Type to check
* @param U - Type to against
* @param type - Type to check
* @param type2 - Type to against
*

@@ -40,7 +43,7 @@ * @example

*/
export type IsNarrowable<T, U> = IsUnknown<T> extends true ? false : IsNever<(T extends U ? true : false) & (U extends T ? false : true)> extends true ? false : true;
export type IsNarrowable<type, type2> = IsUnknown<type> extends true ? false : IsNever<(type extends type2 ? true : false) & (type2 extends type ? false : true)> extends true ? false : true;
/**
* Checks if {@link T} is `never`
* Checks if {@link type} is `never`
*
* @param T - Type to check
* @param type - Type to check
*

@@ -51,8 +54,8 @@ * @example

*/
export type IsNever<T> = [T] extends [never] ? true : false;
export type IsNever<type> = [type] extends [never] ? true : false;
/**
* Checks if {@link T} is `unknown`
* Checks if {@link type} is `unknown`
*
* @param T - Type to check
* @returns `true` if {@link T} is `unknown`, otherwise `false`
* @param type - Type to check
* @returns `true` if {@link type} is `unknown`, otherwise `false`
*

@@ -63,8 +66,8 @@ * @example

*/
export type IsUnknown<T> = unknown extends T ? true : false;
export type IsUnknown<type> = unknown extends type ? true : false;
/**
* Joins array into string
*
* @param T - Array to join
* @param U - Separator
* @param array - Array to join
* @param separator - Separator
* @returns string

@@ -76,9 +79,9 @@ *

*/
export type Join<T extends readonly unknown[], U extends string | number> = T extends readonly [infer F, ...infer R] ? R['length'] extends 0 ? `${F & string}` : `${F & string}${U}${Join<R, U>}` : never;
export type Join<array extends readonly unknown[], separator extends string | number> = array extends readonly [infer head, ...infer tail] ? tail['length'] extends 0 ? `${head & string}` : `${head & string}${separator}${Join<tail, separator>}` : never;
/**
* Merges two object types into new type
*
* @param Object1 - Object to merge into
* @param Object2 - Object to merge and override keys from {@link Object1}
* @returns New object type with keys from {@link Object1} and {@link Object2}. If a key exists in both {@link Object1} and {@link Object2}, the key from {@link Object2} will be used.
* @param object1 - Object to merge into
* @param object2 - Object to merge and override keys from {@link object1}
* @returns New object type with keys from {@link object1} and {@link object2}. If a key exists in both {@link object1} and {@link object2}, the key from {@link object2} will be used.
*

@@ -89,7 +92,7 @@ * @example

*/
export type Merge<Object1, Object2> = Omit<Object1, keyof Object2> & Object2;
export type Merge<object1, object2> = Omit<object1, keyof object2> & object2;
/**
* Makes objects destructurable.
*
* @param Union - Union to distribute.
* @param union - Union to distribute.
*

@@ -100,6 +103,6 @@ * @example

*/
export type OneOf<Union extends object, AllKeys extends KeyofUnion<Union> = KeyofUnion<Union>> = Union extends infer Item ? Pretty<Item & {
[K in Exclude<AllKeys, keyof Item>]?: never;
export type OneOf<union extends object, allKeys extends KeyofUnion<union> = KeyofUnion<union>> = union extends infer item ? Pretty<item & {
[key in Exclude<allKeys, keyof item>]?: never;
}> : never;
type KeyofUnion<T> = T extends T ? keyof T : never;
type KeyofUnion<type> = type extends type ? keyof type : never;
/**

@@ -113,4 +116,4 @@ * Combines members of an intersection into a readable type.

*/
export type Pretty<T> = {
[K in keyof T]: T[K];
export type Pretty<type> = {
[key in keyof type]: type[key];
} & unknown;

@@ -120,5 +123,5 @@ /**

*
* @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}
*

@@ -129,8 +132,8 @@ * @example

*/
export 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>;
export 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>;
/**
* Trims empty space from type T.
* Trims empty space from type {@link t}.
*
* @param T - Type to trim
* @param Chars - Characters to trim
* @param t - Type to trim
* @param chars - Characters to trim
* @returns Trimmed type

@@ -142,11 +145,11 @@ *

*/
export type Trim<T, Chars extends string = ' '> = TrimLeft<TrimRight<T, Chars>, Chars>;
type TrimLeft<T, Chars extends string = ' '> = T extends `${Chars}${infer R}` ? TrimLeft<R> : T;
type TrimRight<T, Chars extends string = ' '> = T extends `${infer R}${Chars}` ? TrimRight<R> : T;
export type Trim<type, chars extends string = ' '> = TrimLeft<TrimRight<type, chars>, chars>;
type TrimLeft<t, chars extends string = ' '> = t extends `${chars}${infer tail}` ? TrimLeft<tail> : t;
type TrimRight<t, chars extends string = ' '> = t extends `${infer head}${chars}` ? TrimRight<head> : t;
/**
* Create tuple of {@link Type} type with {@link Size} size
* Create tuple of {@link type} type with {@link size} size
*
* @param Type - Type of tuple
* @param Size - Size of tuple
* @returns Tuple of {@link Type} type with {@link Size} size
* @returns Tuple of {@link type} type with {@link size} size
*

@@ -157,5 +160,5 @@ * @example

*/
export type Tuple<Type, Size extends number> = Size extends Size ? number extends Size ? Type[] : _TupleOf<Type, Size, []> : never;
type _TupleOf<TNumber, TSize extends number, R extends readonly unknown[]> = R['length'] extends TSize ? R : _TupleOf<TNumber, TSize, readonly [TNumber, ...R]>;
export type Tuple<type, size extends number> = size extends size ? number extends size ? type[] : _TupleOf<type, size, []> : never;
type _TupleOf<length, size extends number, acc extends readonly unknown[]> = acc['length'] extends size ? acc : _TupleOf<length, size, readonly [length, ...acc]>;
export {};
//# sourceMappingURL=types.d.ts.map

190

dist/types/utils.d.ts

@@ -9,11 +9,11 @@ import type { Abi, AbiParameter, AbiParameterKind, AbiStateMutability, AbiType, MBits, SolidityArray, SolidityBytes, SolidityFixedArrayRange, SolidityFixedArraySizeLookup, SolidityInt, SolidityTuple, TypedData, TypedDataParameter, TypedDataType } from './abi.js';

*
* @param TAbiType - {@link AbiType} to convert to TypeScript representation
* @param TAbiParameterKind - Optional {@link AbiParameterKind} to narrow by parameter type
* @param abiType - {@link AbiType} to convert to TypeScript representation
* @param abiParameterKind - Optional {@link AbiParameterKind} to narrow by parameter type
* @returns TypeScript primitive type
*/
export type AbiTypeToPrimitiveType<TAbiType extends AbiType, TAbiParameterKind extends AbiParameterKind = AbiParameterKind> = TAbiType extends SolidityBytes ? PrimitiveTypeLookup[TAbiType][TAbiParameterKind] : PrimitiveTypeLookup[TAbiType];
export type AbiTypeToPrimitiveType<abiType extends AbiType, abiParameterKind extends AbiParameterKind = AbiParameterKind> = abiType extends SolidityBytes ? PrimitiveTypeLookup[abiType][abiParameterKind] : PrimitiveTypeLookup[abiType];
interface PrimitiveTypeLookup extends SolidityIntMap, SolidityByteMap, SolidityArrayMap {
address: ResolvedRegister['AddressType'];
address: ResolvedRegister['addressType'];
bool: boolean;
function: `${ResolvedRegister['AddressType']}${string}`;
function: `${ResolvedRegister['addressType']}${string}`;
string: string;

@@ -23,6 +23,6 @@ tuple: Record<string, unknown>;

type SolidityIntMap = {
[_ in SolidityInt]: _ extends `${'u' | ''}int${infer TBits extends keyof BitsTypeLookup}` ? BitsTypeLookup[TBits] : never;
[_ in SolidityInt]: _ extends `${'u' | ''}int${infer bits extends keyof BitsTypeLookup}` ? BitsTypeLookup[bits] : never;
};
type SolidityByteMap = {
[_ in SolidityBytes]: ResolvedRegister['BytesType'];
[_ in SolidityBytes]: ResolvedRegister['bytesType'];
};

@@ -36,3 +36,3 @@ type SolidityArrayMap = {

type BitsTypeLookup = {
[K in MBits]: ResolvedRegister[K extends LessThanOrEqualTo48Bits ? 'IntType' : 'BigIntType'];
[key in MBits]: ResolvedRegister[key extends LessThanOrEqualTo48Bits ? 'intType' : 'bigIntType'];
};

@@ -42,25 +42,25 @@ /**

*
* @param TAbiParameter - {@link AbiParameter} to convert to TypeScript representation
* @param TAbiParameterKind - Optional {@link AbiParameterKind} to narrow by parameter type
* @param abiParameter - {@link AbiParameter} to convert to TypeScript representation
* @param abiParameterKind - Optional {@link AbiParameterKind} to narrow by parameter type
* @returns TypeScript primitive type
*/
export type AbiParameterToPrimitiveType<TAbiParameter extends AbiParameter | {
export type AbiParameterToPrimitiveType<abiParameter extends AbiParameter | {
name: string;
type: unknown;
}, TAbiParameterKind extends AbiParameterKind = AbiParameterKind> = TAbiParameter['type'] extends AbiBasicType ? AbiTypeToPrimitiveType<TAbiParameter['type'], TAbiParameterKind> : TAbiParameter extends {
}, abiParameterKind extends AbiParameterKind = AbiParameterKind> = abiParameter['type'] extends AbiBasicType ? AbiTypeToPrimitiveType<abiParameter['type'], abiParameterKind> : abiParameter extends {
type: SolidityTuple;
components: infer TComponents extends readonly AbiParameter[];
} ? AbiComponentsToPrimitiveType<TComponents, TAbiParameterKind> : MaybeExtractArrayParameterType<TAbiParameter['type']> extends [
infer Head extends string,
infer Size
] ? AbiArrayToPrimitiveType<TAbiParameter, TAbiParameterKind, Head, Size> : ResolvedRegister['StrictAbiType'] extends true ? Error<`Unknown type '${TAbiParameter['type'] & string}'.`> : TAbiParameter extends {
components: infer components extends readonly AbiParameter[];
} ? AbiComponentsToPrimitiveType<components, abiParameterKind> : MaybeExtractArrayParameterType<abiParameter['type']> extends [
infer head extends string,
infer size
] ? AbiArrayToPrimitiveType<abiParameter, abiParameterKind, head, size> : ResolvedRegister['strictAbiType'] extends true ? Error<`Unknown type '${abiParameter['type'] & string}'.`> : abiParameter extends {
components: Error<string>;
} ? TAbiParameter['components'] : unknown;
} ? abiParameter['components'] : unknown;
type AbiBasicType = Exclude<AbiType, SolidityTuple | SolidityArray>;
type AbiComponentsToPrimitiveType<Components extends readonly AbiParameter[], TAbiParameterKind extends AbiParameterKind> = Components extends readonly [] ? [] : Components[number]['name'] extends Exclude<Components[number]['name'] & string, undefined | ''> ? {
[Component in Components[number] as Component['name'] & {}]: AbiParameterToPrimitiveType<Component, TAbiParameterKind>;
type AbiComponentsToPrimitiveType<components extends readonly AbiParameter[], abiParameterKind extends AbiParameterKind> = components extends readonly [] ? [] : components[number]['name'] extends Exclude<components[number]['name'] & string, undefined | ''> ? {
[component in components[number] as component['name'] & {}]: AbiParameterToPrimitiveType<component, abiParameterKind>;
} : {
[I in keyof Components]: AbiParameterToPrimitiveType<Components[I], TAbiParameterKind>;
[key in keyof components]: AbiParameterToPrimitiveType<components[key], abiParameterKind>;
};
type MaybeExtractArrayParameterType<T> =
type MaybeExtractArrayParameterType<type> =
/**

@@ -74,20 +74,20 @@ * First, infer `Head` against a known size type (either fixed-length array value or `""`).

*/
T extends `${infer Head}[${'' | `${SolidityFixedArrayRange}`}]` ? T extends `${Head}[${infer Size}]` ? [Head, Size] : undefined : undefined;
type AbiArrayToPrimitiveType<TAbiParameter extends AbiParameter | {
type extends `${infer head}[${'' | `${SolidityFixedArrayRange}`}]` ? type extends `${head}[${infer size}]` ? [head, size] : undefined : undefined;
type AbiArrayToPrimitiveType<abiParameter extends AbiParameter | {
name: string;
type: unknown;
}, TAbiParameterKind extends AbiParameterKind, Head extends string, Size> = Size extends keyof SolidityFixedArraySizeLookup ? Tuple<AbiParameterToPrimitiveType<Merge<TAbiParameter, {
type: Head;
}>, TAbiParameterKind>, SolidityFixedArraySizeLookup[Size]> : readonly AbiParameterToPrimitiveType<Merge<TAbiParameter, {
type: Head;
}>, TAbiParameterKind>[];
}, abiParameterKind extends AbiParameterKind, head extends string, size> = size extends keyof SolidityFixedArraySizeLookup ? Tuple<AbiParameterToPrimitiveType<Merge<abiParameter, {
type: head;
}>, abiParameterKind>, SolidityFixedArraySizeLookup[size]> : readonly AbiParameterToPrimitiveType<Merge<abiParameter, {
type: head;
}>, abiParameterKind>[];
/**
* Converts array of {@link AbiParameter} to corresponding TypeScript primitive types.
*
* @param TAbiParameters - Array of {@link AbiParameter} to convert to TypeScript representations
* @param TAbiParameterKind - Optional {@link AbiParameterKind} to narrow by parameter type
* @param abiParameters - Array of {@link AbiParameter} to convert to TypeScript representations
* @param abiParameterKind - Optional {@link AbiParameterKind} to narrow by parameter type
* @returns Array of TypeScript primitive types
*/
export type AbiParametersToPrimitiveTypes<TAbiParameters extends readonly AbiParameter[], TAbiParameterKind extends AbiParameterKind = AbiParameterKind> = Pretty<{
[K in keyof TAbiParameters]: AbiParameterToPrimitiveType<TAbiParameters[K], TAbiParameterKind>;
export type AbiParametersToPrimitiveTypes<abiParameters extends readonly AbiParameter[], abiParameterKind extends AbiParameterKind = AbiParameterKind> = Pretty<{
[key in keyof abiParameters]: AbiParameterToPrimitiveType<abiParameters[key], abiParameterKind>;
}>;

@@ -97,16 +97,16 @@ /**

*
* @param TAbi - {@link Abi} to check
* @returns Boolean for whether {@link TAbi} is {@link Abi}
* @param abi - {@link Abi} to check
* @returns Boolean for whether {@link abi} is {@link Abi}
*/
export type IsAbi<TAbi> = TAbi extends Abi ? true : false;
export type IsAbi<abi> = abi extends Abi ? true : false;
/**
* Extracts all {@link AbiFunction} types from {@link Abi}.
*
* @param TAbi - {@link Abi} to extract functions from
* @param TAbiStateMutability - {@link AbiStateMutability} to filter by
* @param abi - {@link Abi} to extract functions from
* @param abiStateMutability - {@link AbiStateMutability} to filter by
* @returns All {@link AbiFunction} types from {@link Abi}
*/
export type ExtractAbiFunctions<TAbi extends Abi, TAbiStateMutability extends AbiStateMutability = AbiStateMutability> = Extract<TAbi[number], {
export type ExtractAbiFunctions<abi extends Abi, abiStateMutability extends AbiStateMutability = AbiStateMutability> = Extract<abi[number], {
type: 'function';
stateMutability: TAbiStateMutability;
stateMutability: abiStateMutability;
}>;

@@ -116,17 +116,17 @@ /**

*
* @param TAbi - {@link Abi} to extract function names from
* @param TAbiStateMutability - {@link AbiStateMutability} to filter by
* @param abi - {@link Abi} to extract function names from
* @param abiStateMutability - {@link AbiStateMutability} to filter by
* @returns Union of function names
*/
export type ExtractAbiFunctionNames<TAbi extends Abi, TAbiStateMutability extends AbiStateMutability = AbiStateMutability> = ExtractAbiFunctions<TAbi, TAbiStateMutability>['name'];
export type ExtractAbiFunctionNames<abi extends Abi, abiStateMutability extends AbiStateMutability = AbiStateMutability> = ExtractAbiFunctions<abi, abiStateMutability>['name'];
/**
* Extracts {@link AbiFunction} with name from {@link Abi}.
*
* @param TAbi - {@link Abi} to extract {@link AbiFunction} from
* @param TFunctionName - String name of function to extract from {@link Abi}
* @param TAbiStateMutability - {@link AbiStateMutability} to filter by
* @param abi - {@link Abi} to extract {@link AbiFunction} from
* @param functionName - String name of function to extract from {@link Abi}
* @param abiStateMutability - {@link AbiStateMutability} to filter by
* @returns Matching {@link AbiFunction}
*/
export type ExtractAbiFunction<TAbi extends Abi, TFunctionName extends ExtractAbiFunctionNames<TAbi>, TAbiStateMutability extends AbiStateMutability = AbiStateMutability> = Extract<ExtractAbiFunctions<TAbi, TAbiStateMutability>, {
name: TFunctionName;
export type ExtractAbiFunction<abi extends Abi, functionName extends ExtractAbiFunctionNames<abi>, abiStateMutability extends AbiStateMutability = AbiStateMutability> = Extract<ExtractAbiFunctions<abi, abiStateMutability>, {
name: functionName;
}>;

@@ -136,6 +136,6 @@ /**

*
* @param TAbi - {@link Abi} to extract events from
* @param abi - {@link Abi} to extract events from
* @returns All {@link AbiEvent} types from {@link Abi}
*/
export type ExtractAbiEvents<TAbi extends Abi> = Extract<TAbi[number], {
export type ExtractAbiEvents<abi extends Abi> = Extract<abi[number], {
type: 'event';

@@ -146,15 +146,15 @@ }>;

*
* @param TAbi - {@link Abi} to extract event names from
* @param abi - {@link Abi} to extract event names from
* @returns Union of event names
*/
export type ExtractAbiEventNames<TAbi extends Abi> = ExtractAbiEvents<TAbi>['name'];
export type ExtractAbiEventNames<abi extends Abi> = ExtractAbiEvents<abi>['name'];
/**
* Extracts {@link AbiEvent} with name from {@link Abi}.
*
* @param TAbi - {@link Abi} to extract {@link AbiEvent} from
* @param TEventName - String name of event to extract from {@link Abi}
* @param abi - {@link Abi} to extract {@link AbiEvent} from
* @param eventName - String name of event to extract from {@link Abi}
* @returns Matching {@link AbiEvent}
*/
export type ExtractAbiEvent<TAbi extends Abi, TEventName extends ExtractAbiEventNames<TAbi>> = Extract<ExtractAbiEvents<TAbi>, {
name: TEventName;
export type ExtractAbiEvent<abi extends Abi, eventName extends ExtractAbiEventNames<abi>> = Extract<ExtractAbiEvents<abi>, {
name: eventName;
}>;

@@ -164,6 +164,6 @@ /**

*
* @param TAbi - {@link Abi} to extract errors from
* @param abi - {@link Abi} to extract errors from
* @returns All {@link AbiError} types from {@link Abi}
*/
export type ExtractAbiErrors<TAbi extends Abi> = Extract<TAbi[number], {
export type ExtractAbiErrors<abi extends Abi> = Extract<abi[number], {
type: 'error';

@@ -174,15 +174,15 @@ }>;

*
* @param TAbi - {@link Abi} to extract error names from
* @param abi - {@link Abi} to extract error names from
* @returns Union of error names
*/
export type ExtractAbiErrorNames<TAbi extends Abi> = ExtractAbiErrors<TAbi>['name'];
export type ExtractAbiErrorNames<abi extends Abi> = ExtractAbiErrors<abi>['name'];
/**
* Extracts {@link AbiError} with name from {@link Abi}.
*
* @param TAbi - {@link Abi} to extract {@link AbiError} from
* @param TErrorName - String name of error to extract from {@link Abi}
* @param abi - {@link Abi} to extract {@link AbiError} from
* @param errorName - String name of error to extract from {@link Abi}
* @returns Matching {@link AbiError}
*/
export type ExtractAbiError<TAbi extends Abi, TErrorName extends ExtractAbiErrorNames<TAbi>> = Extract<ExtractAbiErrors<TAbi>, {
name: TErrorName;
export type ExtractAbiError<abi extends Abi, errorName extends ExtractAbiErrorNames<abi>> = Extract<ExtractAbiErrors<abi>, {
name: errorName;
}>;

@@ -192,55 +192,55 @@ /**

*
* @param TTypedData - {@link TypedData} to check
* @returns Boolean for whether {@link TTypedData} is {@link TypedData}
* @param typedData - {@link TypedData} to check
* @returns Boolean for whether {@link typedData} is {@link TypedData}
*/
export type IsTypedData<TTypedData> = TTypedData extends TypedData ? {
[K in keyof TTypedData]: {
[K2 in TTypedData[K][number] as K2['type'] extends keyof TTypedData ? never : K2['type'] extends `${keyof TTypedData & string}[${string}]` ? never : K2['type'] extends TypedDataType ? never : K2['name']]: false;
export type IsTypedData<typedData> = typedData extends TypedData ? {
[key in keyof typedData]: {
[key2 in typedData[key][number] as key2['type'] extends keyof typedData ? never : key2['type'] extends `${keyof typedData & string}[${string}]` ? never : key2['type'] extends TypedDataType ? never : key2['name']]: false;
};
} extends {
[K in keyof TTypedData]: Record<string, never>;
[key in keyof typedData]: Record<string, never>;
} ? true : false : false;
/**
* Converts {@link TTypedData} to corresponding TypeScript primitive types.
* Converts {@link typedData} to corresponding TypeScript primitive types.
*
* @param TTypedData - {@link TypedData} to convert
* @param TAbiParameterKind - Optional {@link AbiParameterKind} to narrow by parameter type
* @param typedData - {@link TypedData} to convert
* @param abiParameterKind - Optional {@link AbiParameterKind} to narrow by parameter type
* @returns Union of TypeScript primitive types
*/
export type TypedDataToPrimitiveTypes<TTypedData extends TypedData, TAbiParameterKind extends AbiParameterKind = AbiParameterKind, TKeyReferences extends {
export type TypedDataToPrimitiveTypes<typedData extends TypedData, abiParameterKind extends AbiParameterKind = AbiParameterKind, keyReferences extends {
[_: string]: unknown;
} | unknown = unknown> = {
[K in keyof TTypedData]: {
[K2 in TTypedData[K][number] as K2['name']]: K2['type'] extends K ? Error<`Cannot convert self-referencing struct '${K2['type']}' to primitive type.`> : K2['type'] extends keyof TTypedData ? K2['type'] extends keyof TKeyReferences ? Error<`Circular reference detected. '${K2['type']}' is a circular reference.`> : TypedDataToPrimitiveTypes<Exclude<TTypedData, K>, TAbiParameterKind, TKeyReferences & {
[_ in K2['type'] | K]: true;
}>[K2['type']] : K2['type'] extends `${infer TType extends keyof TTypedData & string}[${infer Tail}]` ? AbiParameterToPrimitiveType<{
name: K2['name'];
type: `tuple[${Tail}]`;
components: _TypedDataParametersToAbiParameters<TTypedData[TType], TTypedData, TKeyReferences & {
[_ in TType | K]: true;
[key in keyof typedData]: {
[key2 in typedData[key][number] as key2['name']]: key2['type'] extends key ? Error<`Cannot convert self-referencing struct '${key2['type']}' to primitive type.`> : key2['type'] extends keyof typedData ? key2['type'] extends keyof keyReferences ? Error<`Circular reference detected. '${key2['type']}' is a circular reference.`> : TypedDataToPrimitiveTypes<Exclude<typedData, key>, abiParameterKind, keyReferences & {
[_ in key2['type'] | key]: true;
}>[key2['type']] : key2['type'] extends `${infer type extends keyof typedData & string}[${infer tail}]` ? AbiParameterToPrimitiveType<{
name: key2['name'];
type: `tuple[${tail}]`;
components: _TypedDataParametersToAbiParameters<typedData[type], typedData, keyReferences & {
[_ in type | key]: true;
}>;
}, TAbiParameterKind> : K2['type'] extends TypedDataType ? AbiParameterToPrimitiveType<K2, TAbiParameterKind> : Error<`Cannot convert unknown type '${K2['type']}' to primitive type.`>;
}, abiParameterKind> : key2['type'] extends TypedDataType ? AbiParameterToPrimitiveType<key2, abiParameterKind> : Error<`Cannot convert unknown type '${key2['type']}' to primitive type.`>;
};
} & unknown;
type _TypedDataParametersToAbiParameters<TTypedDataParameters extends readonly TypedDataParameter[], TTypedData extends TypedData, TKeyReferences extends {
type _TypedDataParametersToAbiParameters<typedDataParameters extends readonly TypedDataParameter[], typedData extends TypedData, keyReferences extends {
[_: string]: unknown;
} | unknown = unknown> = {
[K in keyof TTypedDataParameters]: TTypedDataParameters[K] extends infer TTypedDataParameter extends {
[key in keyof typedDataParameters]: typedDataParameters[key] extends infer typedDataParameter extends {
name: string;
type: unknown;
} ? TTypedDataParameter['type'] extends keyof TTypedData & string ? {
name: TTypedDataParameter['name'];
} ? typedDataParameter['type'] extends keyof typedData & string ? {
name: typedDataParameter['name'];
type: 'tuple';
components: TTypedDataParameter['type'] extends keyof TKeyReferences ? Error<`Circular reference detected. '${TTypedDataParameter['type']}' is a circular reference.`> : _TypedDataParametersToAbiParameters<TTypedData[TTypedDataParameter['type']], TTypedData, TKeyReferences & {
[_ in TTypedDataParameter['type']]: true;
components: typedDataParameter['type'] extends keyof keyReferences ? Error<`Circular reference detected. '${typedDataParameter['type']}' is a circular reference.`> : _TypedDataParametersToAbiParameters<typedData[typedDataParameter['type']], typedData, keyReferences & {
[_ in typedDataParameter['type']]: true;
}>;
} : TTypedDataParameter['type'] extends `${infer TType extends keyof TTypedData & string}[${infer Tail}]` ? {
name: TTypedDataParameter['name'];
type: `tuple[${Tail}]`;
components: TType extends keyof TKeyReferences ? Error<`Circular reference detected. '${TTypedDataParameter['type']}' is a circular reference.`> : _TypedDataParametersToAbiParameters<TTypedData[TType], TTypedData, TKeyReferences & {
[_ in TType]: true;
} : typedDataParameter['type'] extends `${infer type extends keyof typedData & string}[${infer tail}]` ? {
name: typedDataParameter['name'];
type: `tuple[${tail}]`;
components: type extends keyof keyReferences ? Error<`Circular reference detected. '${typedDataParameter['type']}' is a circular reference.`> : _TypedDataParametersToAbiParameters<typedData[type], typedData, keyReferences & {
[_ in type]: true;
}>;
} : TTypedDataParameter : never;
} : typedDataParameter : never;
};
export {};
//# sourceMappingURL=utils.d.ts.map

2

dist/types/version.d.ts

@@ -1,2 +0,2 @@

export declare const version = "0.0.0-canary.20240315T081554";
export declare const version = "0.0.0-canary-20240620192132";
//# sourceMappingURL=version.d.ts.map

68

dist/types/zod.d.ts

@@ -39,28 +39,28 @@ import { z } from 'zod';

}, "strip", z.ZodTypeAny, {
inputs: readonly AbiParameterType[];
outputs: readonly AbiParameterType[];
type: "function";
name: string;
inputs: readonly AbiParameterType[];
outputs: readonly AbiParameterType[];
stateMutability: "pure" | "view" | "nonpayable" | "payable";
payable?: boolean | undefined;
constant?: boolean | undefined;
gas?: number | undefined;
payable?: boolean | undefined;
}, {
inputs: readonly AbiParameterType[];
outputs: readonly AbiParameterType[];
type: "function";
name: string;
inputs: AbiParameterType[];
outputs: AbiParameterType[];
stateMutability: "pure" | "view" | "nonpayable" | "payable";
payable?: boolean | undefined;
constant?: boolean | undefined;
gas?: number | undefined;
payable?: boolean | undefined;
}>, {
inputs: readonly AbiParameterType[];
outputs: readonly AbiParameterType[];
type: "function";
name: string;
inputs: readonly AbiParameterType[];
outputs: readonly AbiParameterType[];
stateMutability: "pure" | "view" | "nonpayable" | "payable";
payable?: boolean | undefined;
constant?: boolean | undefined;
gas?: number | undefined;
payable?: boolean | undefined;
}, unknown>;

@@ -81,14 +81,14 @@ export declare const AbiConstructor: z.ZodEffects<z.ZodObject<{

}, "strip", z.ZodTypeAny, {
inputs: readonly AbiParameterType[];
type: "constructor";
inputs: readonly AbiParameterType[];
stateMutability: "nonpayable" | "payable";
payable?: boolean | undefined;
}, {
inputs: readonly AbiParameterType[];
type: "constructor";
inputs: AbiParameterType[];
stateMutability: "nonpayable" | "payable";
payable?: boolean | undefined;
}>, {
inputs: readonly AbiParameterType[];
type: "constructor";
inputs: readonly AbiParameterType[];
stateMutability: "nonpayable" | "payable";

@@ -142,10 +142,10 @@ payable?: boolean | undefined;

}, "strip", z.ZodTypeAny, {
inputs: readonly AbiEventParameterType[];
type: "event";
name: string;
inputs: readonly AbiEventParameterType[];
anonymous?: boolean | undefined;
}, {
inputs: readonly AbiEventParameterType[];
type: "event";
name: string;
inputs: AbiEventParameterType[];
anonymous?: boolean | undefined;

@@ -158,9 +158,9 @@ }>;

}, "strip", z.ZodTypeAny, {
inputs: readonly AbiParameterType[];
type: "error";
name: string;
}, {
inputs: readonly AbiParameterType[];
}, {
type: "error";
name: string;
inputs: AbiParameterType[];
}>;

@@ -179,9 +179,9 @@ export declare const AbiItemType: z.ZodUnion<[z.ZodLiteral<"constructor">, z.ZodLiteral<"event">, z.ZodLiteral<"error">, z.ZodLiteral<"fallback">, z.ZodLiteral<"function">, z.ZodLiteral<"receive">]>;

}, "strip", z.ZodTypeAny, {
inputs: readonly AbiParameterType[];
type: "error";
name: string;
}, {
inputs: readonly AbiParameterType[];
}, {
type: "error";
name: string;
inputs: AbiParameterType[];
}>, z.ZodObject<{

@@ -193,10 +193,10 @@ type: z.ZodLiteral<"event">;

}, "strip", z.ZodTypeAny, {
inputs: readonly AbiEventParameterType[];
type: "event";
name: string;
inputs: readonly AbiEventParameterType[];
anonymous?: boolean | undefined;
}, {
inputs: readonly AbiEventParameterType[];
type: "event";
name: string;
inputs: AbiEventParameterType[];
anonymous?: boolean | undefined;

@@ -220,9 +220,9 @@ }>, z.ZodEffects<z.ZodIntersection<z.ZodObject<{

}, "strip", z.ZodTypeAny, {
payable?: boolean | undefined;
constant?: boolean | undefined;
gas?: number | undefined;
}, {
payable?: boolean | undefined;
}, {
constant?: boolean | undefined;
gas?: number | undefined;
payable?: boolean | undefined;
}>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{

@@ -235,12 +235,12 @@ type: z.ZodLiteral<"function">;

}, "strip", z.ZodTypeAny, {
inputs: readonly AbiParameterType[];
outputs: readonly AbiParameterType[];
type: "function";
name: string;
stateMutability: "pure" | "view" | "nonpayable" | "payable";
}, {
inputs: readonly AbiParameterType[];
outputs: readonly AbiParameterType[];
stateMutability: "pure" | "view" | "nonpayable" | "payable";
}, {
type: "function";
name: string;
inputs: AbiParameterType[];
outputs: AbiParameterType[];
stateMutability: "pure" | "view" | "nonpayable" | "payable";

@@ -252,8 +252,8 @@ }>, z.ZodObject<{

}, "strip", z.ZodTypeAny, {
inputs: readonly AbiParameterType[];
type: "constructor";
inputs: readonly AbiParameterType[];
stateMutability: "nonpayable" | "payable";
}, {
inputs: readonly AbiParameterType[];
type: "constructor";
inputs: AbiParameterType[];
stateMutability: "nonpayable" | "payable";

@@ -282,14 +282,14 @@ }>, z.ZodObject<{

}>]>>, {
payable?: boolean | undefined;
constant?: boolean | undefined;
gas?: number | undefined;
payable?: boolean | undefined;
} & ({
inputs: readonly AbiParameterType[];
outputs: readonly AbiParameterType[];
type: "function";
name: string;
inputs: readonly AbiParameterType[];
outputs: readonly AbiParameterType[];
stateMutability: "pure" | "view" | "nonpayable" | "payable";
} | {
inputs: readonly AbiParameterType[];
type: "constructor";
inputs: readonly AbiParameterType[];
stateMutability: "nonpayable" | "payable";

@@ -311,4 +311,4 @@ } | {

}, "strip", z.ZodTypeAny, {
name?: string | undefined;
chainId?: number | undefined;
name?: string | undefined;
salt?: string | undefined;

@@ -318,4 +318,4 @@ verifyingContract?: `0x${string}` | undefined;

}, {
name?: string | undefined;
chainId?: number | undefined;
name?: string | undefined;
salt?: string | undefined;

@@ -322,0 +322,0 @@ verifyingContract?: string | undefined;

32

package.json
{
"name": "abitype",
"description": "Strict TypeScript types for Ethereum ABIs",
"version": "0.0.0-canary.20240315T081554",
"version": "0.0.0-canary-20240620192132",
"license": "MIT",
"repository": "wevm/abitype",
"scripts": {
"build": "pnpm run clean && pnpm run build:cjs && pnpm run build:esm+types",
"build:cjs": "tsc --project tsconfig.build.json --module commonjs --moduleResolution node10 --outDir ./dist/cjs --removeComments --verbatimModuleSyntax false && echo > ./dist/cjs/package.json '{\"type\":\"commonjs\"}'",
"build:esm+types": "tsc --project tsconfig.build.json --module es2020 --outDir ./dist/esm --declaration --declarationMap --declarationDir ./dist/types && echo > ./dist/esm/package.json '{\"type\":\"module\",\"sideEffects\":false}'",
"clean": "rm -rf dist tsconfig.tsbuildinfo abis zod",
"test:build": "publint --strict",
"typebench": "tsx src/**.bench-d.ts --benchPercentThreshold 20 --benchErrorOnThresholdExceeded",
"typecheck": "tsc --noEmit",
"typeperf": "tsc --noEmit --extendedDiagnostics --composite false --incremental false"
},
"files": [
"dist",
"/abis",
"/zod",
"src/**/*.ts",
"!dist/**/*.tsbuildinfo",
"src/**/*.ts",
"!src/**/*.test.ts",
"!jsr.json",
"!src/**/*.bench.ts",
"!src/**/*.test-d.ts",
"!src/**/*.bench.ts",
"!src/**/*.bench-d.ts",
"/abis",
"/zod"
"!src/**/*.test.ts"
],
"sideEffects": false,
"type": "module",
"main": "./dist/cjs/exports/index.js",

@@ -74,7 +63,2 @@ "module": "./dist/esm/exports/index.js",

},
"devDependencies": {
"@ethersproject/abi": "^5.7.0",
"ethers": "^6.5.1",
"zod": "^3.22.4"
},
"contributors": [

@@ -96,2 +80,2 @@ "awkweb.eth <t@wevm.dev>",

]
}
}

4

README.md

@@ -73,3 +73,3 @@ <br/>

- You want to [typecheck](https://abitype.dev/api/types) your ABIs or EIP-712 Typed Data.
- You want to add type inference and autocomplete to your library based on user-provided ABIs or EIP-712 Typed Data, like [wagmi](https://wagmi.sh) and [viem](https://viem.sh).
- You want to add type inference and autocomplete to your library based on user-provided ABIs or EIP-712 Typed Data, like [Wagmi](https://wagmi.sh) and [Viem](https://viem.sh).
- You need to [convert ABI types](https://abitype.dev/api/utilities#abiparameterstoprimitivetypes) (e.g. `'string'`) to TypeScript types (e.g. `string`) or other type transformations.

@@ -91,3 +91,3 @@ - You need to validate ABIs at [runtime](https://abitype.dev/api/zod) (e.g. after fetching from external resource).

[Join the Wagmi Discord](https://discord.gg/SghfWBKexF)
[Join the Wevm Discord](https://discord.gg/SghfWBKexF)

@@ -94,0 +94,0 @@ ## Sponsors

29

src/abi.ts
import type { ResolvedRegister } from './register.js'
import type { Pretty, Range } from './types.js'
export type Address = ResolvedRegister['AddressType']
export type Address = ResolvedRegister['addressType']

@@ -40,4 +40,4 @@ ////////////////////////////////////////////////////////////////////////////////////////////////////

export type SolidityFixedArrayRange = Range<
ResolvedRegister['FixedArrayMinLength'],
ResolvedRegister['FixedArrayMaxLength']
ResolvedRegister['fixedArrayMinLength'],
ResolvedRegister['fixedArrayMaxLength']
>[number]

@@ -55,9 +55,12 @@ export type SolidityFixedArraySizeLookup = {

Depth extends readonly number[] = [],
> = ResolvedRegister['ArrayMaxDepth'] extends false
> = 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]>
: Depth['length'] extends ResolvedRegister['arrayMaxDepth']
? T
: T extends `${any}[${SolidityFixedArrayRange | ''}]`
? _BuildArrayTypes<
T | `${T}[${SolidityFixedArrayRange | ''}]`,
[...Depth, 1]
>
: _BuildArrayTypes<`${T}[${SolidityFixedArrayRange | ''}]`, [...Depth, 1]>

@@ -89,3 +92,3 @@ // Modeling fixed-length (`<type>[M]`) and dynamic (`<type>[]`) arrays

| SolidityTuple
type ResolvedAbiType = ResolvedRegister['StrictAbiType'] extends true
type ResolvedAbiType = ResolvedRegister['strictAbiType'] extends true
? AbiType

@@ -116,5 +119,3 @@ : string

export type AbiEventParameter = Pretty<
AbiParameter & { indexed?: boolean | undefined }
>
export type AbiEventParameter = AbiParameter & { indexed?: boolean | undefined }

@@ -227,3 +228,3 @@ /**

name?: string | undefined
salt?: ResolvedRegister['BytesType']['outputs'] | undefined
salt?: ResolvedRegister['bytesType']['outputs'] | undefined
verifyingContract?: Address | undefined

@@ -230,0 +231,0 @@ version?: string | undefined

4

src/errors.ts

@@ -24,4 +24,4 @@ import type { OneOf, Pretty } from './types.js'

: args.cause?.message
? args.cause.message
: args.details!
? args.cause.message
: args.details!
const docsPath =

@@ -28,0 +28,0 @@ args.cause instanceof BaseError

26

src/human-readable/formatAbi.ts

@@ -7,14 +7,14 @@ import type { Abi } from '../abi.js'

*
* @param TAbi - ABI
* @param abi - ABI
* @returns Human-readable ABI
*/
export type FormatAbi<TAbi extends Abi | readonly unknown[]> = Abi extends TAbi
export type FormatAbi<abi extends Abi | readonly unknown[]> = Abi extends abi
? readonly string[]
: TAbi extends readonly []
? never
: TAbi extends Abi
? {
[K in keyof TAbi]: FormatAbiItem<TAbi[K]>
}
: readonly string[]
: abi extends readonly []
? never
: abi extends Abi
? {
[key in keyof abi]: FormatAbiItem<abi[key]>
}
: readonly string[]

@@ -27,5 +27,5 @@ /**

*/
export function formatAbi<const TAbi extends Abi | readonly unknown[]>(
abi: TAbi,
): FormatAbi<TAbi> {
export function formatAbi<const abi extends Abi | readonly unknown[]>(
abi: abi,
): FormatAbi<abi> {
const signatures = []

@@ -38,3 +38,3 @@ const length = abi.length

}
return signatures as unknown as FormatAbi<TAbi>
return signatures as unknown as FormatAbi<abi>
}

78

src/human-readable/formatAbiItem.ts

@@ -22,53 +22,53 @@ import type {

*
* @param TAbiItem - ABI item
* @param abiItem - ABI item
* @returns Human-readable ABI item
*/
export type FormatAbiItem<TAbiItem extends Abi[number]> =
Abi[number] extends TAbiItem
export type FormatAbiItem<abiItem extends Abi[number]> =
Abi[number] extends abiItem
? string
:
| (TAbiItem extends AbiFunction
? AbiFunction extends TAbiItem
| (abiItem extends AbiFunction
? AbiFunction extends abiItem
? string
: `function ${AssertName<TAbiItem['name']>}(${FormatAbiParameters<
TAbiItem['inputs']
>})${TAbiItem['stateMutability'] extends Exclude<
: `function ${AssertName<abiItem['name']>}(${FormatAbiParameters<
abiItem['inputs']
>})${abiItem['stateMutability'] extends Exclude<
AbiStateMutability,
'nonpayable'
>
? ` ${TAbiItem['stateMutability']}`
: ''}${TAbiItem['outputs']['length'] extends 0
? ` ${abiItem['stateMutability']}`
: ''}${abiItem['outputs']['length'] extends 0
? ''
: ` returns (${FormatAbiParameters<TAbiItem['outputs']>})`}`
: ` returns (${FormatAbiParameters<abiItem['outputs']>})`}`
: never)
| (TAbiItem extends AbiEvent
? AbiEvent extends TAbiItem
| (abiItem extends AbiEvent
? AbiEvent extends abiItem
? string
: `event ${AssertName<TAbiItem['name']>}(${FormatAbiParameters<
TAbiItem['inputs']
: `event ${AssertName<abiItem['name']>}(${FormatAbiParameters<
abiItem['inputs']
>})`
: never)
| (TAbiItem extends AbiError
? AbiError extends TAbiItem
| (abiItem extends AbiError
? AbiError extends abiItem
? string
: `error ${AssertName<TAbiItem['name']>}(${FormatAbiParameters<
TAbiItem['inputs']
: `error ${AssertName<abiItem['name']>}(${FormatAbiParameters<
abiItem['inputs']
>})`
: never)
| (TAbiItem extends AbiConstructor
? AbiConstructor extends TAbiItem
| (abiItem extends AbiConstructor
? AbiConstructor extends abiItem
? string
: `constructor(${FormatAbiParameters<
TAbiItem['inputs']
>})${TAbiItem['stateMutability'] extends 'payable'
abiItem['inputs']
>})${abiItem['stateMutability'] extends 'payable'
? ' payable'
: ''}`
: never)
| (TAbiItem extends AbiFallback
? AbiFallback extends TAbiItem
| (abiItem extends AbiFallback
? AbiFallback extends abiItem
? string
: 'fallback()'
: never)
| (TAbiItem extends AbiReceive
? AbiReceive extends TAbiItem
| (abiItem extends AbiReceive
? AbiReceive extends abiItem
? string

@@ -79,11 +79,11 @@ : 'receive() external payable'

type FormatAbiParameters<
TAbiParameters extends readonly (AbiParameter | AbiEventParameter)[],
> = TAbiParameters['length'] extends 0
abiParameters extends readonly (AbiParameter | AbiEventParameter)[],
> = abiParameters['length'] extends 0
? ''
: FormatAbiParameters_<
TAbiParameters extends readonly [
abiParameters extends readonly [
AbiParameter | AbiEventParameter,
...(readonly (AbiParameter | AbiEventParameter)[]),
]
? TAbiParameters
? abiParameters
: never

@@ -98,6 +98,6 @@ >

*/
export function formatAbiItem<const TAbiItem extends Abi[number]>(
abiItem: TAbiItem,
): FormatAbiItem<TAbiItem> {
type Result = FormatAbiItem<TAbiItem>
export function formatAbiItem<const abiItem extends Abi[number]>(
abiItem: abiItem,
): FormatAbiItem<abiItem> {
type Result = FormatAbiItem<abiItem>
type Params = readonly [

@@ -120,16 +120,16 @@ AbiParameter | AbiEventParameter,

}`
else if (abiItem.type === 'event')
if (abiItem.type === 'event')
return `event ${abiItem.name}(${formatAbiParameters(
abiItem.inputs as Params,
)})`
else if (abiItem.type === 'error')
if (abiItem.type === 'error')
return `error ${abiItem.name}(${formatAbiParameters(
abiItem.inputs as Params,
)})`
else if (abiItem.type === 'constructor')
if (abiItem.type === 'constructor')
return `constructor(${formatAbiParameters(abiItem.inputs as Params)})${
abiItem.stateMutability === 'payable' ? ' payable' : ''
}`
else if (abiItem.type === 'fallback') return 'fallback()' as Result
if (abiItem.type === 'fallback') return 'fallback()' as Result
return 'receive() external payable' as Result
}

48

src/human-readable/formatAbiParameter.ts

@@ -9,3 +9,3 @@ import type { AbiEventParameter, AbiParameter } from '../abi.js'

*
* @param TAbiParameter - ABI parameter
* @param abiParameter - ABI parameter
* @returns Human-readable ABI parameter

@@ -18,8 +18,8 @@ *

export type FormatAbiParameter<
TAbiParameter extends AbiParameter | AbiEventParameter,
> = TAbiParameter extends {
name?: infer Name extends string
type: `tuple${infer Array}`
components: infer Components extends readonly AbiParameter[]
indexed?: infer Indexed extends boolean
abiParameter extends AbiParameter | AbiEventParameter,
> = abiParameter extends {
name?: infer name extends string
type: `tuple${infer array}`
components: infer components extends readonly AbiParameter[]
indexed?: infer indexed extends boolean
}

@@ -30,10 +30,10 @@ ? FormatAbiParameter<

{
[K in keyof Components]: FormatAbiParameter<
[key in keyof components]: FormatAbiParameter<
{
type: Components[K]['type']
} & (IsNarrowable<Components[K]['name'], string> extends true
? { name: Components[K]['name'] }
type: components[key]['type']
} & (IsNarrowable<components[key]['name'], string> extends true
? { name: components[key]['name'] }
: unknown) &
(Components[K] extends { components: readonly AbiParameter[] }
? { components: Components[K]['components'] }
(components[key] extends { components: readonly AbiParameter[] }
? { components: components[key]['components'] }
: unknown)

@@ -43,14 +43,14 @@ >

', '
>})${Array}`
} & (IsNarrowable<Name, string> extends true ? { name: Name } : unknown) &
(IsNarrowable<Indexed, boolean> extends true
? { indexed: Indexed }
>})${array}`
} & (IsNarrowable<name, string> extends true ? { name: name } : unknown) &
(IsNarrowable<indexed, boolean> extends true
? { indexed: indexed }
: unknown)
>
: `${TAbiParameter['type']}${TAbiParameter extends { indexed: true }
: `${abiParameter['type']}${abiParameter extends { indexed: true }
? ' indexed'
: ''}${TAbiParameter['name'] extends infer Name extends string
? Name extends ''
: ''}${abiParameter['name'] extends infer name extends string
? name extends ''
? ''
: ` ${AssertName<Name>}`
: ` ${AssertName<name>}`
: ''}`

@@ -72,5 +72,5 @@

export function formatAbiParameter<
const TAbiParameter extends AbiParameter | AbiEventParameter,
>(abiParameter: TAbiParameter): FormatAbiParameter<TAbiParameter> {
type Result = FormatAbiParameter<TAbiParameter>
const abiParameter extends AbiParameter | AbiEventParameter,
>(abiParameter: abiParameter): FormatAbiParameter<abiParameter> {
type Result = FormatAbiParameter<abiParameter>

@@ -77,0 +77,0 @@ let type = abiParameter.type

12

src/human-readable/formatAbiParameters.ts

@@ -11,3 +11,3 @@ import type { AbiEventParameter, AbiParameter } from '../abi.js'

*
* @param TAbiParameters - ABI parameters
* @param abiParameters - ABI parameters
* @returns Human-readable ABI parameters

@@ -23,3 +23,3 @@ *

export type FormatAbiParameters<
TAbiParameters extends readonly [
abiParameters extends readonly [
AbiParameter | AbiEventParameter,

@@ -30,3 +30,3 @@ ...(readonly (AbiParameter | AbiEventParameter)[]),

{
[K in keyof TAbiParameters]: FormatAbiParameter<TAbiParameters[K]>
[key in keyof abiParameters]: FormatAbiParameter<abiParameters[key]>
},

@@ -50,7 +50,7 @@ ', '

export function formatAbiParameters<
const TAbiParameters extends readonly [
const abiParameters extends readonly [
AbiParameter | AbiEventParameter,
...(readonly (AbiParameter | AbiEventParameter)[]),
],
>(abiParameters: TAbiParameters): FormatAbiParameters<TAbiParameters> {
>(abiParameters: abiParameters): FormatAbiParameters<abiParameters> {
let params = ''

@@ -63,3 +63,3 @@ const length = abiParameters.length

}
return params as FormatAbiParameters<TAbiParameters>
return params as FormatAbiParameters<abiParameters>
}

44

src/human-readable/parseAbi.ts

@@ -13,3 +13,3 @@ import type { Abi } from '../abi.js'

*
* @param TSignatures - Human-readable ABI
* @param signatures - Human-readable ABI
* @returns Parsed {@link Abi}

@@ -26,17 +26,18 @@ *

*/
export type ParseAbi<TSignatures extends readonly string[]> =
string[] extends TSignatures
export type ParseAbi<signatures extends readonly string[]> =
string[] extends signatures
? Abi // If `T` was not able to be inferred (e.g. just `string[]`), return `Abi`
: TSignatures extends readonly string[]
? TSignatures extends Signatures<TSignatures> // Validate signatures
? ParseStructs<TSignatures> extends infer Structs
? {
[K in keyof TSignatures]: TSignatures[K] extends string
? ParseSignature<TSignatures[K], Structs>
: signatures extends readonly string[]
? signatures extends Signatures<signatures> // Validate signatures
? ParseStructs<signatures> extends infer sructs
? {
[key in keyof signatures]: signatures[key] extends string
? ParseSignature<signatures[key], sructs>
: never
} extends infer mapped extends readonly unknown[]
? Filter<mapped, never> extends infer result
? result extends readonly []
? never
: result
: never
} extends infer Mapped extends readonly unknown[]
? Filter<Mapped, never> extends infer Result
? Result extends readonly []
? never
: Result
: never

@@ -46,3 +47,2 @@ : never

: never
: never

@@ -62,9 +62,9 @@ /**

*/
export function parseAbi<const TSignatures extends readonly string[]>(
signatures: TSignatures['length'] extends 0
export function parseAbi<const signatures extends readonly string[]>(
signatures: signatures['length'] extends 0
? Error<'At least one signature required'>
: Signatures<TSignatures> extends TSignatures
? TSignatures
: Signatures<TSignatures>,
): ParseAbi<TSignatures> {
: Signatures<signatures> extends signatures
? signatures
: Signatures<signatures>,
): ParseAbi<signatures> {
const structs = parseStructs(signatures as readonly string[])

@@ -78,3 +78,3 @@ const abi = []

}
return abi as unknown as ParseAbi<TSignatures>
return abi as unknown as ParseAbi<signatures>
}

76

src/human-readable/parseAbiItem.ts

@@ -15,3 +15,3 @@ import type { Abi } from '../abi.js'

*
* @param TSignature - Human-readable ABI item
* @param signature - Human-readable ABI item
* @returns Parsed {@link Abi} item

@@ -30,31 +30,31 @@ *

export type ParseAbiItem<
TSignature extends string | readonly string[] | readonly unknown[],
signature extends string | readonly string[] | readonly unknown[],
> =
| (TSignature extends string
? string extends TSignature
| (signature extends string
? string extends signature
? Abi[number]
: TSignature extends Signature<TSignature> // Validate signature
? ParseSignature<TSignature>
: never
: signature extends Signature<signature> // Validate signature
? ParseSignature<signature>
: never
: never)
| (TSignature extends readonly string[]
? string[] extends TSignature
| (signature extends readonly string[]
? string[] extends signature
? Abi[number] // Return generic Abi item since type was no inferrable
: TSignature extends Signatures<TSignature> // Validate signature
? ParseStructs<TSignature> extends infer Structs
? {
[K in keyof TSignature]: ParseSignature<
TSignature[K] extends string ? TSignature[K] : never,
Structs
>
} extends infer Mapped extends readonly unknown[]
? // Filter out `never` since those are structs
Filter<Mapped, never>[0] extends infer Result
? Result extends undefined // convert `undefined` to `never` (e.g. `ParseAbiItem<['struct Foo { string name; }']>`)
? never
: Result
: signature extends Signatures<signature> // Validate signature
? ParseStructs<signature> extends infer structs
? {
[key in keyof signature]: ParseSignature<
signature[key] extends string ? signature[key] : never,
structs
>
} extends infer mapped extends readonly unknown[]
? // Filter out `never` since those are structs
Filter<mapped, never>[0] extends infer result
? result extends undefined // convert `undefined` to `never` (e.g. `ParseAbiItem<['struct Foo { string name; }']>`)
? never
: result
: never
: never
: never
: never
: never
: never)

@@ -80,23 +80,23 @@

export function parseAbiItem<
TSignature extends string | readonly string[] | readonly unknown[],
signature extends string | readonly string[] | readonly unknown[],
>(
signature: Narrow<TSignature> &
signature: Narrow<signature> &
(
| (TSignature extends string
? string extends TSignature
| (signature extends string
? string extends signature
? unknown
: Signature<TSignature>
: Signature<signature>
: never)
| (TSignature extends readonly string[]
? TSignature extends readonly [] // empty array
| (signature extends readonly string[]
? signature extends readonly [] // empty array
? Error<'At least one signature required.'>
: string[] extends TSignature
? unknown
: Signatures<TSignature>
: string[] extends signature
? unknown
: Signatures<signature>
: never)
),
): ParseAbiItem<TSignature> {
let abiItem
): ParseAbiItem<signature> {
let abiItem: ParseAbiItem<signature> | undefined
if (typeof signature === 'string')
abiItem = parseSignature(signature) as ParseAbiItem<TSignature>
abiItem = parseSignature(signature) as ParseAbiItem<signature>
else {

@@ -108,3 +108,3 @@ const structs = parseStructs(signature as readonly string[])

if (isStructSignature(signature_)) continue
abiItem = parseSignature(signature_, structs)
abiItem = parseSignature(signature_, structs) as ParseAbiItem<signature>
break

@@ -115,3 +115,3 @@ }

if (!abiItem) throw new InvalidAbiItemError({ signature })
return abiItem as ParseAbiItem<TSignature>
return abiItem as ParseAbiItem<signature>
}

72

src/human-readable/parseAbiParameter.ts

@@ -15,3 +15,3 @@ import type { AbiParameter } from '../abi.js'

*
* @param TParam - Human-readable ABI parameter
* @param param - Human-readable ABI parameter
* @returns Parsed {@link AbiParameter}

@@ -30,32 +30,32 @@ *

export type ParseAbiParameter<
TParam extends string | readonly string[] | readonly unknown[],
param extends string | readonly string[] | readonly unknown[],
> =
| (TParam extends string
? TParam extends ''
| (param extends string
? param extends ''
? never
: string extends TParam
? AbiParameter
: ParseAbiParameter_<TParam, { Modifier: Modifier }>
: string extends param
? AbiParameter
: ParseAbiParameter_<param, { modifier: Modifier }>
: never)
| (TParam extends readonly string[]
? string[] extends TParam
| (param extends readonly string[]
? string[] extends param
? AbiParameter // Return generic AbiParameter item since type was no inferrable
: ParseStructs<TParam> extends infer Structs
? {
[K in keyof TParam]: TParam[K] extends string
? IsStructSignature<TParam[K]> extends true
: ParseStructs<param> extends infer structs
? {
[key in keyof param]: param[key] extends string
? IsStructSignature<param[key]> extends true
? never
: ParseAbiParameter_<
param[key],
{ modifier: Modifier; structs: structs }
>
: never
} extends infer mapped extends readonly unknown[]
? Filter<mapped, never>[0] extends infer result
? result extends undefined
? never
: ParseAbiParameter_<
TParam[K],
{ Modifier: Modifier; Structs: Structs }
>
: result
: never
} extends infer Mapped extends readonly unknown[]
? Filter<Mapped, never>[0] extends infer Result
? Result extends undefined
? never
: Result
: never
: never
: never
: never)

@@ -81,25 +81,25 @@

export function parseAbiParameter<
TParam extends string | readonly string[] | readonly unknown[],
param extends string | readonly string[] | readonly unknown[],
>(
param: Narrow<TParam> &
param: Narrow<param> &
(
| (TParam extends string
? TParam extends ''
| (param extends string
? param extends ''
? Error<'Empty string is not allowed.'>
: unknown
: never)
| (TParam extends readonly string[]
? TParam extends readonly [] // empty array
| (param extends readonly string[]
? param extends readonly [] // empty array
? Error<'At least one parameter required.'>
: string[] extends TParam
? unknown
: unknown // TODO: Validate param string
: string[] extends param
? unknown
: unknown // TODO: Validate param string
: never)
),
): ParseAbiParameter<TParam> {
let abiParameter
): ParseAbiParameter<param> {
let abiParameter: AbiParameter | undefined
if (typeof param === 'string')
abiParameter = parseAbiParameter_(param, {
modifiers,
}) as ParseAbiParameter<TParam>
}) as ParseAbiParameter<param>
else {

@@ -118,3 +118,3 @@ const structs = parseStructs(param as readonly string[])

return abiParameter as ParseAbiParameter<TParam>
return abiParameter as ParseAbiParameter<param>
}

78

src/human-readable/parseAbiParameters.ts

@@ -17,3 +17,3 @@ import type { AbiParameter } from '../abi.js'

*
* @param TParams - Human-readable ABI parameters
* @param params - Human-readable ABI parameters
* @returns Parsed {@link AbiParameter}s

@@ -32,32 +32,32 @@ *

export type ParseAbiParameters<
TParams extends string | readonly string[] | readonly unknown[],
params extends string | readonly string[] | readonly unknown[],
> =
| (TParams extends string
? TParams extends ''
| (params extends string
? params extends ''
? never
: string extends TParams
? readonly AbiParameter[]
: ParseAbiParameters_<SplitParameters<TParams>, { Modifier: Modifier }>
: string extends params
? readonly AbiParameter[]
: ParseAbiParameters_<SplitParameters<params>, { modifier: Modifier }>
: never)
| (TParams extends readonly string[]
? string[] extends TParams
| (params extends readonly string[]
? string[] extends params
? AbiParameter // Return generic AbiParameter item since type was no inferrable
: ParseStructs<TParams> extends infer Structs
? {
[K in keyof TParams]: TParams[K] extends string
? IsStructSignature<TParams[K]> extends true
: ParseStructs<params> extends infer structs
? {
[key in keyof params]: params[key] extends string
? IsStructSignature<params[key]> extends true
? never
: ParseAbiParameters_<
SplitParameters<params[key]>,
{ modifier: Modifier; structs: structs }
>
: never
} extends infer mapped extends readonly unknown[]
? Filter<mapped, never> extends readonly [...infer content]
? content['length'] extends 0
? never
: ParseAbiParameters_<
SplitParameters<TParams[K]>,
{ Modifier: Modifier; Structs: Structs }
>
: DeepFlatten<content>
: never
} extends infer Mapped extends readonly unknown[]
? Filter<Mapped, never> extends readonly [...infer Content]
? Content['length'] extends 0
? never
: DeepFlatten<Content>
: never
: never
: never
: never)

@@ -79,8 +79,8 @@

Acc extends readonly unknown[] = readonly [],
> = T extends readonly [infer Head, ...infer Tail]
? Tail extends undefined
> = T extends readonly [infer head, ...infer tail]
? tail extends undefined
? never
: Head extends readonly unknown[]
? DeepFlatten<Tail, readonly [...Acc, ...DeepFlatten<Head>]>
: DeepFlatten<Tail, readonly [...Acc, Head]>
: head extends readonly unknown[]
? DeepFlatten<tail, readonly [...Acc, ...DeepFlatten<head>]>
: DeepFlatten<tail, readonly [...Acc, head]>
: Acc

@@ -106,20 +106,20 @@

export function parseAbiParameters<
TParams extends string | readonly string[] | readonly unknown[],
params extends string | readonly string[] | readonly unknown[],
>(
params: Narrow<TParams> &
params: Narrow<params> &
(
| (TParams extends string
? TParams extends ''
| (params extends string
? params extends ''
? Error<'Empty string is not allowed.'>
: unknown
: never)
| (TParams extends readonly string[]
? TParams extends readonly [] // empty array
| (params extends readonly string[]
? params extends readonly [] // empty array
? Error<'At least one parameter required.'>
: string[] extends TParams
? unknown
: unknown // TODO: Validate param string
: string[] extends params
? unknown
: unknown // TODO: Validate param string
: never)
),
): ParseAbiParameters<TParams> {
): ParseAbiParameters<params> {
const abiParameters: AbiParameter[] = []

@@ -151,3 +151,3 @@ if (typeof params === 'string') {

return abiParameters as ParseAbiParameters<TParams>
return abiParameters as ParseAbiParameters<params>
}

184

src/human-readable/types/signatures.ts

@@ -5,39 +5,34 @@ import type { AbiStateMutability } from '../../abi.js'

export type ErrorSignature<
TName extends string = string,
TParameters extends string = string,
> = `error ${TName}(${TParameters})`
export type IsErrorSignature<T extends string> = T extends ErrorSignature<
infer Name
>
? IsName<Name>
: false
name extends string = string,
parameters extends string = string,
> = `error ${name}(${parameters})`
export type IsErrorSignature<signature extends string> =
signature extends ErrorSignature<infer name> ? IsName<name> : false
export type EventSignature<
TName extends string = string,
TParameters extends string = string,
> = `event ${TName}(${TParameters})`
export type IsEventSignature<T extends string> = T extends EventSignature<
infer Name
>
? IsName<Name>
: false
name extends string = string,
parameters extends string = string,
> = `event ${name}(${parameters})`
export type IsEventSignature<signature extends string> =
signature extends EventSignature<infer name> ? IsName<name> : false
export type FunctionSignature<
TName extends string = string,
TTail extends string = string,
> = `function ${TName}(${TTail}`
export type IsFunctionSignature<T> = T extends FunctionSignature<infer Name>
? IsName<Name> extends true
? T extends ValidFunctionSignatures
? true
: // Check that `Parameters` is not absorbing other types (e.g. `returns`)
T extends `function ${string}(${infer Parameters})`
? Parameters extends InvalidFunctionParameters
? false
: true
name extends string = string,
tail extends string = string,
> = `function ${name}(${tail}`
export type IsFunctionSignature<signature> =
signature extends FunctionSignature<infer name>
? IsName<name> extends true
? signature extends ValidFunctionSignatures
? true
: // Check that `Parameters` is not absorbing other types (e.g. `returns`)
signature extends `function ${string}(${infer parameters})`
? parameters extends InvalidFunctionParameters
? false
: true
: false
: false
: false
: false
export type Scope = 'public' | 'external' // `internal` or `private` functions wouldn't make it to ABI so can ignore
type Returns = `returns (${string})` | `returns(${string})`
// Almost all valid function signatures, except `function ${string}(${infer Parameters})` since `Parameters` can absorb returns
// Almost all valid function signatures, except `function ${string}(${infer parameters})` since `parameters` can absorb returns
type ValidFunctionSignatures =

@@ -64,18 +59,15 @@ | `function ${string}()`

export type StructSignature<
TName extends string = string,
TProperties extends string = string,
> = `struct ${TName} {${TProperties}}`
export type IsStructSignature<T extends string> = T extends StructSignature<
infer Name
>
? IsName<Name>
: false
name extends string = string,
properties extends string = string,
> = `struct ${name} {${properties}}`
export type IsStructSignature<signature extends string> =
signature extends StructSignature<infer name> ? IsName<name> : false
type ConstructorSignature<TTail extends string = string> =
`constructor(${TTail}`
export type IsConstructorSignature<T> = T extends ConstructorSignature
? T extends ValidConstructorSignatures
? true
type ConstructorSignature<tail extends string = string> = `constructor(${tail}`
export type IsConstructorSignature<signature> =
signature extends ConstructorSignature
? signature extends ValidConstructorSignatures
? true
: false
: false
: false
type ValidConstructorSignatures =

@@ -85,5 +77,4 @@ | `constructor(${string})`

export type FallbackSignature<
TAbiStateMutability extends '' | ' payable' = '',
> = `fallback() external${TAbiStateMutability}`
export type FallbackSignature<abiStateMutability extends '' | ' payable' = ''> =
`fallback() external${abiStateMutability}`

@@ -94,11 +85,11 @@ export type ReceiveSignature = 'receive() external payable'

// https://twitter.com/devanshj__/status/1610423724708343808
export type IsSignature<T extends string> =
| (IsErrorSignature<T> extends true ? true : never)
| (IsEventSignature<T> extends true ? true : never)
| (IsFunctionSignature<T> extends true ? true : never)
| (IsStructSignature<T> extends true ? true : never)
| (IsConstructorSignature<T> extends true ? true : never)
| (T extends FallbackSignature ? true : never)
| (T extends ReceiveSignature ? true : never) extends infer Condition
? [Condition] extends [never]
export type IsSignature<type extends string> =
| (IsErrorSignature<type> extends true ? true : never)
| (IsEventSignature<type> extends true ? true : never)
| (IsFunctionSignature<type> extends true ? true : never)
| (IsStructSignature<type> extends true ? true : never)
| (IsConstructorSignature<type> extends true ? true : never)
| (type extends FallbackSignature ? true : never)
| (type extends ReceiveSignature ? true : never) extends infer condition
? [condition] extends [never]
? false

@@ -109,14 +100,14 @@ : true

export type Signature<
T extends string,
K extends string | unknown = unknown,
> = IsSignature<T> extends true
? T
: string extends T // if exactly `string` (not narrowed), then pass through as valid
? T
: Error<`Signature "${T}" is invalid${K extends string
? ` at position ${K}`
: ''}.`>
string1 extends string,
string2 extends string | unknown = unknown,
> = IsSignature<string1> extends true
? string1
: string extends string1 // if exactly `string` (not narrowed), then pass through as valid
? string1
: Error<`Signature "${string1}" is invalid${string2 extends string
? ` at position ${string2}`
: ''}.`>
export type Signatures<T extends readonly string[]> = {
[K in keyof T]: Signature<T[K], K>
export type Signatures<signatures extends readonly string[]> = {
[key in keyof signatures]: Signature<signatures[key], key>
}

@@ -131,33 +122,32 @@

export type IsName<TName extends string> = TName extends ''
export type IsName<name extends string> = name extends ''
? false
: ValidateName<TName> extends TName
? true
: false
: ValidateName<name> extends name
? true
: false
export type AssertName<TName extends string> =
ValidateName<TName> extends infer InvalidName extends string[]
? `[${InvalidName[number]}]`
: TName
export type AssertName<name extends string> =
ValidateName<name> extends infer invalidName extends string[]
? `[${invalidName[number]}]`
: name
export type ValidateName<
TName extends string,
CheckCharacters extends boolean = false,
> = TName extends `${string}${' '}${string}`
? Error<`Identifier "${TName}" cannot contain whitespace.`>
: IsSolidityKeyword<TName> extends true
? Error<`"${TName}" is a protected Solidity keyword.`>
: TName extends `${number}`
? Error<`Identifier "${TName}" cannot be a number string.`>
: TName extends `${number}${string}`
? Error<`Identifier "${TName}" cannot start with a number.`>
: CheckCharacters extends true
? IsValidCharacter<TName> extends true
? TName
: Error<`"${TName}" contains invalid character.`>
: TName
name extends string,
checkCharacters extends boolean = false,
> = name extends `${string}${' '}${string}`
? Error<`Identifier "${name}" cannot contain whitespace.`>
: IsSolidityKeyword<name> extends true
? Error<`"${name}" is a protected Solidity keyword.`>
: name extends `${number}`
? Error<`Identifier "${name}" cannot be a number string.`>
: name extends `${number}${string}`
? Error<`Identifier "${name}" cannot start with a number.`>
: checkCharacters extends true
? IsValidCharacter<name> extends true
? name
: Error<`"${name}" contains invalid character.`>
: name
export type IsSolidityKeyword<T extends string> = T extends SolidityKeywords
? true
: false
export type IsSolidityKeyword<type extends string> =
type extends SolidityKeywords ? true : false

@@ -229,7 +219,7 @@ export type SolidityKeywords =

export type IsValidCharacter<T extends string> =
T extends `${ValidCharacters}${infer Tail}`
? Tail extends ''
export type IsValidCharacter<character extends string> =
character extends `${ValidCharacters}${infer tail}`
? tail extends ''
? true
: IsValidCharacter<Tail>
: IsValidCharacter<tail>
: false

@@ -236,0 +226,0 @@

95

src/human-readable/types/structs.ts

@@ -8,12 +8,12 @@ import type { AbiParameter } from '../../abi.js'

export type ParseStructs<TSignatures extends readonly string[]> =
export type ParseStructs<signatures extends readonly string[]> =
// Create "shallow" version of each struct (and filter out non-structs or invalid structs)
{
[Signature in
TSignatures[number] as ParseStruct<Signature> extends infer Struct extends {
[signature in signatures[number] as ParseStruct<signature> extends infer struct extends
{
name: string
}
? Struct['name']
: never]: ParseStruct<Signature>['components']
} extends infer Structs extends Record<
? struct['name']
: never]: ParseStruct<signature>['components']
} extends infer structs extends Record<
string,

@@ -24,5 +24,5 @@ readonly (AbiParameter & { type: string })[]

{
[StructName in keyof Structs]: ResolveStructs<
Structs[StructName],
Structs
[structName in keyof structs]: ResolveStructs<
structs[structName],
structs
>

@@ -33,8 +33,8 @@ }

export type ParseStruct<
TSignature extends string,
TStructs extends StructLookup | unknown = unknown,
> = TSignature extends StructSignature<infer Name, infer Properties>
signature extends string,
structs extends StructLookup | unknown = unknown,
> = signature extends StructSignature<infer name, infer properties>
? {
readonly name: Trim<Name>
readonly components: ParseStructProperties<Properties, TStructs>
readonly name: Trim<name>
readonly components: ParseStructProperties<properties, structs>
}

@@ -44,35 +44,34 @@ : never

export type ResolveStructs<
TAbiParameters extends readonly (AbiParameter & { type: string })[],
TStructs extends Record<string, readonly (AbiParameter & { type: string })[]>,
TKeyReferences extends { [_: string]: unknown } | unknown = unknown,
abiParameters extends readonly (AbiParameter & { type: string })[],
structs extends Record<string, readonly (AbiParameter & { type: string })[]>,
keyReferences extends { [_: string]: unknown } | unknown = unknown,
> = readonly [
...{
[K in
keyof TAbiParameters]: TAbiParameters[K]['type'] extends `${infer Head extends string &
keyof TStructs}[${infer Tail}]` // Struct arrays (e.g. `type: 'Struct[]'`, `type: 'Struct[10]'`, `type: 'Struct[][]'`)
? Head extends keyof TKeyReferences
? Error<`Circular reference detected. Struct "${TAbiParameters[K]['type']}" is a circular reference.`>
[key in keyof abiParameters]: abiParameters[key]['type'] extends `${infer head extends
string & keyof structs}[${infer tail}]` // Struct arrays (e.g. `type: 'Struct[]'`, `type: 'Struct[10]'`, `type: 'Struct[][]'`)
? head extends keyof keyReferences
? Error<`Circular reference detected. Struct "${abiParameters[key]['type']}" is a circular reference.`>
: {
readonly name: TAbiParameters[K]['name']
readonly type: `tuple[${Tail}]`
readonly name: abiParameters[key]['name']
readonly type: `tuple[${tail}]`
readonly components: ResolveStructs<
TStructs[Head],
TStructs,
TKeyReferences & { [_ in Head]: true }
structs[head],
structs,
keyReferences & { [_ in head]: true }
>
}
: // Basic struct (e.g. `type: 'Struct'`)
TAbiParameters[K]['type'] extends keyof TStructs
? TAbiParameters[K]['type'] extends keyof TKeyReferences
? Error<`Circular reference detected. Struct "${TAbiParameters[K]['type']}" is a circular reference.`>
: {
readonly name: TAbiParameters[K]['name']
readonly type: 'tuple'
readonly components: ResolveStructs<
TStructs[TAbiParameters[K]['type']],
TStructs,
TKeyReferences & { [_ in TAbiParameters[K]['type']]: true }
>
}
: TAbiParameters[K]
abiParameters[key]['type'] extends keyof structs
? abiParameters[key]['type'] extends keyof keyReferences
? Error<`Circular reference detected. Struct "${abiParameters[key]['type']}" is a circular reference.`>
: {
readonly name: abiParameters[key]['name']
readonly type: 'tuple'
readonly components: ResolveStructs<
structs[abiParameters[key]['type']],
structs,
keyReferences & { [_ in abiParameters[key]['type']]: true }
>
}
: abiParameters[key]
},

@@ -82,11 +81,11 @@ ]

export type ParseStructProperties<
T extends string,
TStructs extends StructLookup | unknown = unknown,
Result extends any[] = [],
> = Trim<T> extends `${infer Head};${infer Tail}`
signature extends string,
structs extends StructLookup | unknown = unknown,
result extends any[] = [],
> = Trim<signature> extends `${infer head};${infer tail}`
? ParseStructProperties<
Tail,
TStructs,
[...Result, ParseAbiParameter<Head, { Structs: TStructs }>]
tail,
structs,
[...result, ParseAbiParameter<head, { structs: structs }>]
>
: Result
: result

433

src/human-readable/types/utils.ts

@@ -28,13 +28,13 @@ import type {

export type ParseSignature<
TSignature extends string,
TStructs extends StructLookup | unknown = unknown,
signature extends string,
structs extends StructLookup | unknown = unknown,
> =
| (IsErrorSignature<TSignature> extends true
? TSignature extends ErrorSignature<infer Name, infer Parameters>
| (IsErrorSignature<signature> extends true
? signature extends ErrorSignature<infer name, infer parameters>
? {
readonly name: Name
readonly name: name
readonly type: 'error'
readonly inputs: ParseAbiParameters<
SplitParameters<Parameters>,
{ Structs: TStructs }
SplitParameters<parameters>,
{ structs: structs }
>

@@ -44,10 +44,10 @@ }

: never)
| (IsEventSignature<TSignature> extends true
? TSignature extends EventSignature<infer Name, infer Parameters>
| (IsEventSignature<signature> extends true
? signature extends EventSignature<infer name, infer parameters>
? {
readonly name: Name
readonly name: name
readonly type: 'event'
readonly inputs: ParseAbiParameters<
SplitParameters<Parameters>,
{ Modifier: EventModifier; Structs: TStructs }
SplitParameters<parameters>,
{ modifier: EventModifier; structs: structs }
>

@@ -57,20 +57,20 @@ }

: never)
| (IsFunctionSignature<TSignature> extends true
? TSignature extends FunctionSignature<infer Name, infer Tail>
| (IsFunctionSignature<signature> extends true
? signature extends FunctionSignature<infer name, infer tail>
? {
readonly name: Name
readonly name: name
readonly type: 'function'
readonly stateMutability: _ParseFunctionParametersAndStateMutability<TSignature>['StateMutability']
readonly stateMutability: _ParseFunctionParametersAndStateMutability<signature>['StateMutability']
readonly inputs: ParseAbiParameters<
SplitParameters<
_ParseFunctionParametersAndStateMutability<TSignature>['Inputs']
_ParseFunctionParametersAndStateMutability<signature>['Inputs']
>,
{ Modifier: FunctionModifier; Structs: TStructs }
{ modifier: FunctionModifier; structs: structs }
>
readonly outputs: Tail extends
| `${string}returns (${infer Returns})`
| `${string}returns(${infer Returns})`
readonly outputs: tail extends
| `${string}returns (${infer returns})`
| `${string}returns(${infer returns})`
? ParseAbiParameters<
SplitParameters<Returns>,
{ Modifier: FunctionModifier; Structs: TStructs }
SplitParameters<returns>,
{ modifier: FunctionModifier; structs: structs }
>

@@ -81,18 +81,18 @@ : readonly []

: never)
| (IsConstructorSignature<TSignature> extends true
| (IsConstructorSignature<signature> extends true
? {
readonly type: 'constructor'
readonly stateMutability: _ParseConstructorParametersAndStateMutability<TSignature>['StateMutability']
readonly stateMutability: _ParseConstructorParametersAndStateMutability<signature>['StateMutability']
readonly inputs: ParseAbiParameters<
SplitParameters<
_ParseConstructorParametersAndStateMutability<TSignature>['Inputs']
_ParseConstructorParametersAndStateMutability<signature>['Inputs']
>,
{ Structs: TStructs }
{ structs: structs }
>
}
: never)
| (TSignature extends FallbackSignature<infer StateMutability>
| (signature extends FallbackSignature<infer stateMutability>
? {
readonly type: 'fallback'
readonly stateMutability: StateMutability extends `${string}payable`
readonly stateMutability: stateMutability extends `${string}payable`
? 'payable'

@@ -102,3 +102,3 @@ : 'nonpayable'

: never)
| (TSignature extends ReceiveSignature
| (signature extends ReceiveSignature
? {

@@ -111,4 +111,4 @@ readonly type: 'receive'

type ParseOptions = {
Modifier?: Modifier
Structs?: StructLookup | unknown
modifier?: Modifier
structs?: StructLookup | unknown
}

@@ -118,9 +118,9 @@ type DefaultParseOptions = object

export type ParseAbiParameters<
T extends readonly string[],
Options extends ParseOptions = DefaultParseOptions,
> = T extends ['']
signatures extends readonly string[],
options extends ParseOptions = DefaultParseOptions,
> = signatures extends ['']
? readonly []
: readonly [
...{
[K in keyof T]: ParseAbiParameter<T[K], Options>
[key in keyof signatures]: ParseAbiParameter<signatures[key], options>
},

@@ -130,18 +130,17 @@ ]

export type ParseAbiParameter<
T extends string,
Options extends ParseOptions = DefaultParseOptions,
signature extends string,
options extends ParseOptions = DefaultParseOptions,
> = (
T extends `(${string})${string}`
? _ParseTuple<T, Options>
signature extends `(${string})${string}`
? _ParseTuple<signature, options>
: // Convert string to shallow AbiParameter (structs resolved yet)
// Check for `${Type} ${NameOrModifier}` format (e.g. `uint256 foo`, `uint256 indexed`, `uint256 indexed foo`)
T extends `${infer Type} ${infer Tail}`
? Trim<Tail> extends infer Trimmed extends string
? // TODO: data location modifiers only allowed for struct/array types
{ readonly type: Trim<Type> } & _SplitNameOrModifier<Trimmed, Options>
: never
: // Must be `${Type}` format (e.g. `uint256`)
{ readonly type: T }
) extends infer ShallowParameter extends AbiParameter & {
// Check for `${Type} ${nameOrModifier}` format (e.g. `uint256 foo`, `uint256 indexed`, `uint256 indexed foo`)
signature extends `${infer type} ${infer tail}`
? Trim<tail> extends infer trimmed extends string
? // TODO: data location modifiers only allowed for struct/array types
{ readonly type: Trim<type> } & _SplitNameOrModifier<trimmed, options>
: never
: // Must be `${Type}` format (e.g. `uint256`)
{ readonly type: signature }
) extends infer shallowParameter extends AbiParameter & {
type: string

@@ -153,26 +152,26 @@ indexed?: boolean

(
ShallowParameter['type'] extends keyof Options['Structs']
shallowParameter['type'] extends keyof options['structs']
? {
readonly type: 'tuple'
readonly components: Options['Structs'][ShallowParameter['type']]
} & (IsUnknown<ShallowParameter['name']> extends false
? { readonly name: ShallowParameter['name'] }
readonly components: options['structs'][shallowParameter['type']]
} & (IsUnknown<shallowParameter['name']> extends false
? { readonly name: shallowParameter['name'] }
: object) &
(ShallowParameter['indexed'] extends true
(shallowParameter['indexed'] extends true
? { readonly indexed: true }
: object)
: // Resolve tuple structs (e.g. `Foo[]`, `Foo[2]`, `Foo[][2]`, etc.)
ShallowParameter['type'] extends `${infer Type extends string &
keyof Options['Structs']}[${infer Tail}]`
? {
readonly type: `tuple[${Tail}]`
readonly components: Options['Structs'][Type]
} & (IsUnknown<ShallowParameter['name']> extends false
? { readonly name: ShallowParameter['name'] }
: object) &
(ShallowParameter['indexed'] extends true
? { readonly indexed: true }
: object)
: // Not a struct, just return
ShallowParameter
shallowParameter['type'] extends `${infer type extends string &
keyof options['structs']}[${infer tail}]`
? {
readonly type: `tuple[${tail}]`
readonly components: options['structs'][type]
} & (IsUnknown<shallowParameter['name']> extends false
? { readonly name: shallowParameter['name'] }
: object) &
(shallowParameter['indexed'] extends true
? { readonly indexed: true }
: object)
: // Not a struct, just return
shallowParameter
) extends infer Parameter extends AbiParameter & {

@@ -187,64 +186,66 @@ type: string

export type SplitParameters<
T extends string,
Result extends unknown[] = [],
Current extends string = '',
Depth extends readonly number[] = [],
> = T extends ''
? Current extends ''
? [...Result] // empty string was passed in to `SplitParameters`
: Depth['length'] extends 0
? [...Result, Trim<Current>]
: Error<`Unbalanced parentheses. "${Current}" has too many opening parentheses.`>
: T extends `${infer Char}${infer Tail}`
? Char extends ','
? Depth['length'] extends 0
? SplitParameters<Tail, [...Result, Trim<Current>], ''>
: SplitParameters<Tail, Result, `${Current}${Char}`, Depth>
: Char extends '('
? SplitParameters<Tail, Result, `${Current}${Char}`, [...Depth, 1]>
: Char extends ')'
? Depth['length'] extends 0
? Error<`Unbalanced parentheses. "${Current}" has too many closing parentheses.`>
: SplitParameters<Tail, Result, `${Current}${Char}`, Pop<Depth>>
: SplitParameters<Tail, Result, `${Current}${Char}`, Depth>
signature extends string,
result extends unknown[] = [],
current extends string = '',
depth extends readonly number[] = [],
> = signature extends ''
? current extends ''
? [...result] // empty string was passed in to `SplitParameters`
: depth['length'] extends 0
? [...result, Trim<current>]
: Error<`Unbalanced parentheses. "${current}" has too many opening parentheses.`>
: signature extends `${infer char}${infer tail}`
? char extends ','
? depth['length'] extends 0
? SplitParameters<tail, [...result, Trim<current>], ''>
: SplitParameters<tail, result, `${current}${char}`, depth>
: char extends '('
? SplitParameters<tail, result, `${current}${char}`, [...depth, 1]>
: char extends ')'
? depth['length'] extends 0
? Error<`Unbalanced parentheses. "${current}" has too many closing parentheses.`>
: SplitParameters<tail, result, `${current}${char}`, Pop<depth>>
: SplitParameters<tail, result, `${current}${char}`, depth>
: []
type Pop<type extends readonly number[]> = type extends [...infer head, any]
? head
: []
type Pop<T extends readonly number[]> = T extends [...infer R, any] ? R : []
export type _ValidateAbiParameter<TAbiParameter extends AbiParameter> =
export type _ValidateAbiParameter<abiParameter extends AbiParameter> =
// Validate `name`
(
TAbiParameter extends { name: string }
? ValidateName<TAbiParameter['name']> extends infer Name
? Name extends TAbiParameter['name']
? TAbiParameter
abiParameter extends { name: string }
? ValidateName<abiParameter['name']> extends infer name
? name extends abiParameter['name']
? abiParameter
: // Add `Error` as `name`
Merge<TAbiParameter, { readonly name: Name }>
Merge<abiParameter, { readonly name: name }>
: never
: TAbiParameter
) extends infer Parameter
: abiParameter
) extends infer parameter
? // Validate `type` against `AbiType`
(
ResolvedRegister['StrictAbiType'] extends true
? Parameter extends { type: AbiType }
? Parameter
ResolvedRegister['strictAbiType'] extends true
? parameter extends { type: AbiType }
? parameter
: Merge<
Parameter,
parameter,
{
readonly type: Error<`Type "${Parameter extends {
readonly type: Error<`Type "${parameter extends {
type: string
}
? Parameter['type']
? parameter['type']
: string}" is not a valid ABI type.`>
}
>
: Parameter
) extends infer Parameter2 extends { type: unknown }
: parameter
) extends infer parameter2 extends { type: unknown }
? // Convert `(u)int` to `(u)int256`
Parameter2['type'] extends `${infer Prefix extends
parameter2['type'] extends `${infer prefix extends
| 'u'
| ''}int${infer Suffix extends `[${string}]` | ''}`
| ''}int${infer suffix extends `[${string}]` | ''}`
? Pretty<
Merge<Parameter2, { readonly type: `${Prefix}int256${Suffix}` }>
Merge<parameter2, { readonly type: `${prefix}int256${suffix}` }>
>
: Parameter2
: parameter2
: never

@@ -254,123 +255,123 @@ : never

export type _ParseFunctionParametersAndStateMutability<
TSignature extends string,
> = TSignature extends
| `${infer Head}returns (${string})`
| `${infer Head}returns(${string})`
? _ParseFunctionParametersAndStateMutability<Trim<Head>>
: TSignature extends `function ${string}(${infer Parameters})`
? { Inputs: Parameters; StateMutability: 'nonpayable' }
: TSignature extends `function ${string}(${infer Parameters}) ${infer ScopeOrStateMutability extends
| Scope
| AbiStateMutability
| `${Scope} ${AbiStateMutability}`}`
? {
Inputs: Parameters
StateMutability: ScopeOrStateMutability extends `${Scope} ${infer StateMutability extends AbiStateMutability}`
? StateMutability
: ScopeOrStateMutability extends AbiStateMutability
? ScopeOrStateMutability
: 'nonpayable'
}
: never
signature extends string,
> = signature extends
| `${infer head}returns (${string})`
| `${infer head}returns(${string})`
? _ParseFunctionParametersAndStateMutability<Trim<head>>
: signature extends `function ${string}(${infer parameters})`
? { Inputs: parameters; StateMutability: 'nonpayable' }
: signature extends `function ${string}(${infer parameters}) ${infer scopeOrStateMutability extends
| Scope
| AbiStateMutability
| `${Scope} ${AbiStateMutability}`}`
? {
Inputs: parameters
StateMutability: scopeOrStateMutability extends `${Scope} ${infer stateMutability extends AbiStateMutability}`
? stateMutability
: scopeOrStateMutability extends AbiStateMutability
? scopeOrStateMutability
: 'nonpayable'
}
: never
type _ParseConstructorParametersAndStateMutability<TSignature extends string,> =
TSignature extends `constructor(${infer Parameters}) payable`
? { Inputs: Parameters; StateMutability: 'payable' }
: TSignature extends `constructor(${infer Parameters})`
? { Inputs: Parameters; StateMutability: 'nonpayable' }
: never
type _ParseConstructorParametersAndStateMutability<signature extends string> =
signature extends `constructor(${infer parameters}) payable`
? { Inputs: parameters; StateMutability: 'payable' }
: signature extends `constructor(${infer parameters})`
? { Inputs: parameters; StateMutability: 'nonpayable' }
: never
export type _ParseTuple<
T extends `(${string})${string}`,
Options extends ParseOptions = DefaultParseOptions,
signature extends `(${string})${string}`,
options extends ParseOptions = DefaultParseOptions,
> = /** Tuples without name or modifier (e.g. `(string)`, `(string foo)`) */
T extends `(${infer Parameters})`
signature extends `(${infer parameters})`
? {
readonly type: 'tuple'
readonly components: ParseAbiParameters<
SplitParameters<Parameters>,
Omit<Options, 'Modifier'>
SplitParameters<parameters>,
Omit<options, 'modifier'>
>
}
: // Array or fixed-length array tuples (e.g. `(string)[]`, `(string)[5]`)
T extends `(${infer Head})[${'' | `${SolidityFixedArrayRange}`}]`
? T extends `(${Head})[${infer Size}]`
? {
readonly type: `tuple[${Size}]`
readonly components: ParseAbiParameters<
SplitParameters<Head>,
Omit<Options, 'Modifier'>
>
}
: never
: // Array or fixed-length array tuples with name and/or modifier attached (e.g. `(string)[] foo`, `(string)[5] foo`)
T extends `(${infer Parameters})[${
| ''
| `${SolidityFixedArrayRange}`}] ${infer NameOrModifier}`
? T extends `(${Parameters})[${infer Size}] ${NameOrModifier}`
? NameOrModifier extends `${string}) ${string}`
? _UnwrapNameOrModifier<NameOrModifier> extends infer Parts extends {
NameOrModifier: string
End: string
}
? {
readonly type: 'tuple'
readonly components: ParseAbiParameters<
SplitParameters<`${Parameters})[${Size}] ${Parts['End']}`>,
Omit<Options, 'Modifier'>
>
} & _SplitNameOrModifier<Parts['NameOrModifier'], Options>
: never
: {
readonly type: `tuple[${Size}]`
readonly components: ParseAbiParameters<
SplitParameters<Parameters>,
Omit<Options, 'Modifier'>
>
} & _SplitNameOrModifier<NameOrModifier, Options>
: never
: // Tuples with name and/or modifier attached (e.g. `(string) foo`, `(string bar) foo`)
T extends `(${infer Parameters}) ${infer NameOrModifier}`
? // Check that `NameOrModifier` didn't get matched to `baz) bar) foo` (e.g. `(((string) baz) bar) foo`)
NameOrModifier extends `${string}) ${string}`
? _UnwrapNameOrModifier<NameOrModifier> extends infer Parts extends {
NameOrModifier: string
End: string
}
signature extends `(${infer head})[${'' | `${SolidityFixedArrayRange}`}]`
? signature extends `(${head})[${infer size}]`
? {
readonly type: 'tuple'
readonly type: `tuple[${size}]`
readonly components: ParseAbiParameters<
SplitParameters<`${Parameters}) ${Parts['End']}`>,
Omit<Options, 'Modifier'>
SplitParameters<head>,
Omit<options, 'modifier'>
>
} & _SplitNameOrModifier<Parts['NameOrModifier'], Options>
}
: never
: {
readonly type: 'tuple'
readonly components: ParseAbiParameters<
SplitParameters<Parameters>,
Omit<Options, 'Modifier'>
>
} & _SplitNameOrModifier<NameOrModifier, Options>
: never
: // Array or fixed-length array tuples with name and/or modifier attached (e.g. `(string)[] foo`, `(string)[5] foo`)
signature extends `(${infer parameters})[${
| ''
| `${SolidityFixedArrayRange}`}] ${infer nameOrModifier}`
? signature extends `(${parameters})[${infer size}] ${nameOrModifier}`
? nameOrModifier extends `${string}) ${string}`
? _UnwrapNameOrModifier<nameOrModifier> extends infer parts extends {
nameOrModifier: string
End: string
}
? {
readonly type: 'tuple'
readonly components: ParseAbiParameters<
SplitParameters<`${parameters})[${size}] ${parts['End']}`>,
Omit<options, 'modifier'>
>
} & _SplitNameOrModifier<parts['nameOrModifier'], options>
: never
: {
readonly type: `tuple[${size}]`
readonly components: ParseAbiParameters<
SplitParameters<parameters>,
Omit<options, 'modifier'>
>
} & _SplitNameOrModifier<nameOrModifier, options>
: never
: // Tuples with name and/or modifier attached (e.g. `(string) foo`, `(string bar) foo`)
signature extends `(${infer parameters}) ${infer nameOrModifier}`
? // Check that `nameOrModifier` didn't get matched to `baz) bar) foo` (e.g. `(((string) baz) bar) foo`)
nameOrModifier extends `${string}) ${string}`
? _UnwrapNameOrModifier<nameOrModifier> extends infer parts extends {
nameOrModifier: string
End: string
}
? {
readonly type: 'tuple'
readonly components: ParseAbiParameters<
SplitParameters<`${parameters}) ${parts['End']}`>,
Omit<options, 'modifier'>
>
} & _SplitNameOrModifier<parts['nameOrModifier'], options>
: never
: {
readonly type: 'tuple'
readonly components: ParseAbiParameters<
SplitParameters<parameters>,
Omit<options, 'modifier'>
>
} & _SplitNameOrModifier<nameOrModifier, options>
: never
// Split name and modifier (e.g. `indexed foo` => `{ name: 'foo', indexed: true }`)
export type _SplitNameOrModifier<
T extends string,
Options extends ParseOptions = DefaultParseOptions,
> = Trim<T> extends infer Trimmed
? Options extends { Modifier: Modifier }
signature extends string,
options extends ParseOptions = DefaultParseOptions,
> = Trim<signature> extends infer trimmed
? options extends { modifier: Modifier }
? // TODO: Check that modifier is allowed
Trimmed extends `${infer Mod extends Options['Modifier']} ${infer Name}`
trimmed extends `${infer mod extends options['modifier']} ${infer name}`
? Pretty<
{ readonly name: Trim<Name> } & (Mod extends 'indexed'
{ readonly name: Trim<name> } & (mod extends 'indexed'
? { readonly indexed: true }
: object)
>
: Trimmed extends Options['Modifier']
? Trimmed extends 'indexed'
? { readonly indexed: true }
: object
: { readonly name: Trimmed }
: { readonly name: Trimmed }
: trimmed extends options['modifier']
? trimmed extends 'indexed'
? { readonly indexed: true }
: object
: { readonly name: trimmed }
: { readonly name: trimmed }
: never

@@ -380,9 +381,9 @@

export type _UnwrapNameOrModifier<
T extends string,
Current extends string = '',
> = T extends `${infer Head}) ${infer Tail}`
signature extends string,
current extends string = '',
> = signature extends `${infer head}) ${infer tail}`
? _UnwrapNameOrModifier<
Tail,
`${Current}${Current extends '' ? '' : ') '}${Head}`
tail,
`${current}${current extends '' ? '' : ') '}${head}`
>
: { End: Trim<Current>; NameOrModifier: Trim<T> }
: { End: Trim<current>; nameOrModifier: Trim<signature> }

16

src/narrow.ts

@@ -5,3 +5,3 @@ /**

* @param T - Type to infer
* @returns Embedded type of {@link TType}
* @returns Embedded type of {@link type}
*

@@ -12,8 +12,8 @@ * @example

// s/o https://twitter.com/hd_nvim/status/1578567206190780417
export 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]> }
export 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]> }

@@ -30,4 +30,4 @@ /**

*/
export function narrow<TType>(value: Narrow<TType>) {
export function narrow<type>(value: Narrow<type>) {
return value
}

4

src/regex.ts
// TODO: This looks cool. Need to check the performance of `new RegExp` versus defined inline though.
// https://twitter.com/GabrielVergnaud/status/1622906834343366657
export function execTyped<T>(regex: RegExp, string: string) {
export function execTyped<type>(regex: RegExp, string: string) {
const match = regex.exec(string)
return match?.groups as T | undefined
return match?.groups as type | undefined
}

@@ -7,0 +7,0 @@

121

src/register.ts

@@ -1,3 +0,5 @@

export type Register = {}
// biome-ignore lint/suspicious/noEmptyInterface: <explanation>
export interface Register {}
// TODO: Remove deprecated properties next major version
export type ResolvedRegister = {

@@ -8,5 +10,7 @@ /**

*/
AddressType: Register extends { AddressType: infer type }
addressType: Register extends { addressType: infer type }
? type
: DefaultRegister['AddressType']
: Register extends { AddressType: infer type }
? type
: DefaultRegister['addressType']
/**

@@ -16,5 +20,7 @@ * TypeScript type to use for `int<M>` and `uint<M>` values, where `M > 48`

*/
BigIntType: Register extends { BigIntType: infer type }
bigIntType: Register extends { bigIntType: infer type }
? type
: DefaultRegister['BigIntType']
: Register extends { BigIntType: infer type }
? type
: DefaultRegister['bigIntType']
/**

@@ -24,7 +30,11 @@ * TypeScript type to use for `bytes` values

*/
BytesType: Register extends {
BytesType: infer type extends { inputs: unknown; outputs: unknown }
bytesType: Register extends {
bytesType: infer type extends { inputs: unknown; outputs: unknown }
}
? type
: DefaultRegister['BytesType']
: Register extends {
BytesType: infer type extends { inputs: unknown; outputs: unknown }
}
? type
: DefaultRegister['bytesType']
/**

@@ -34,5 +44,7 @@ * TypeScript type to use for `int<M>` and `uint<M>` values, where `M <= 48`

*/
IntType: Register extends { IntType: infer type }
intType: Register extends { intType: infer type }
? type
: DefaultRegister['IntType']
: Register extends { IntType: infer type }
? type
: DefaultRegister['intType']

@@ -47,7 +59,11 @@ /**

*/
ArrayMaxDepth: Register extends {
ArrayMaxDepth: infer type extends number | false
arrayMaxDepth: Register extends {
arrayMaxDepth: infer type extends number | false
}
? type
: DefaultRegister['ArrayMaxDepth']
: Register extends {
ArrayMaxDepth: infer type extends number | false
}
? type
: DefaultRegister['arrayMaxDepth']
/**

@@ -57,7 +73,11 @@ * Lower bound for fixed array length

*/
FixedArrayMinLength: Register extends {
FixedArrayMinLength: infer type extends number
fixedArrayMinLength: Register extends {
fixedArrayMinLength: infer type extends number
}
? type
: DefaultRegister['FixedArrayMinLength']
: Register extends {
FixedArrayMinLength: infer type extends number
}
? type
: DefaultRegister['fixedArrayMinLength']
/**

@@ -67,7 +87,11 @@ * Upper bound for fixed array length

*/
FixedArrayMaxLength: Register extends {
FixedArrayMaxLength: infer type extends number
fixedArrayMaxLength: Register extends {
fixedArrayMaxLength: infer type extends number
}
? type
: DefaultRegister['FixedArrayMaxLength']
: Register extends {
FixedArrayMaxLength: infer type extends number
}
? type
: DefaultRegister['fixedArrayMaxLength']

@@ -82,5 +106,24 @@ /**

*/
StrictAbiType: Register extends { StrictAbiType: infer type extends boolean }
strictAbiType: Register extends { strictAbiType: infer type extends boolean }
? type
: DefaultRegister['StrictAbiType']
: Register extends { StrictAbiType: infer type extends boolean }
? 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']
}

@@ -90,12 +133,12 @@

/** 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 */

@@ -107,8 +150,28 @@ inputs: `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']
}

197

src/types.ts
/**
* Prints custom error message
*
* @param T - Error message
* @param messages - Error message
* @returns Custom error message

@@ -11,10 +11,11 @@ *

*/
export type Error<T extends string | string[]> = T extends string
export type Error<messages extends string | string[]> = messages extends string
? [
// Surrounding with array to prevent `T` from being widened to `string`
`Error: ${T}`,
// Surrounding with array to prevent `messages` from being widened to `string`
`Error: ${messages}`,
]
: {
[K in keyof T]: T[K] extends infer Message extends string
? `Error: ${Message}`
[key in keyof messages]: messages[key] extends infer message extends
string
? `Error: ${message}`
: never

@@ -24,6 +25,6 @@ }

/**
* Filters out all members of {@link T} that are {@link P}
* Filters out all members of {@link items} that are {@link item}
*
* @param T - Items to filter
* @param P - Type to filter out
* @param items - Items to filter
* @param item - Type to filter out
* @returns Filtered items

@@ -36,16 +37,20 @@ *

export type Filter<
T extends readonly unknown[],
U,
Acc extends readonly unknown[] = [],
> = T extends readonly [infer F, ...infer Rest extends readonly unknown[]]
? [F] extends [U]
? Filter<Rest, U, Acc>
: Filter<Rest, U, [...Acc, F]>
: readonly [...Acc]
items extends readonly unknown[],
item,
///
acc extends readonly unknown[] = [],
> = items extends readonly [
infer head,
...infer tail extends readonly unknown[],
]
? [head] extends [item]
? Filter<tail, item, acc>
: Filter<tail, item, [...acc, head]>
: readonly [...acc]
/**
* Checks if {@link T} can be narrowed further than {@link U}
* Checks if {@link type} can be narrowed further than {@link type2}
*
* @param T - Type to check
* @param U - Type to against
* @param type - Type to check
* @param type2 - Type to against
*

@@ -56,14 +61,15 @@ * @example

*/
export type IsNarrowable<T, U> = IsUnknown<T> extends true
export type IsNarrowable<type, type2> = IsUnknown<type> extends true
? false
: IsNever<
(T extends U ? true : false) & (U extends T ? false : true)
> extends true
? false
: true
(type extends type2 ? true : false) &
(type2 extends type ? false : true)
> extends true
? false
: true
/**
* Checks if {@link T} is `never`
* Checks if {@link type} is `never`
*
* @param T - Type to check
* @param type - Type to check
*

@@ -74,9 +80,9 @@ * @example

*/
export type IsNever<T> = [T] extends [never] ? true : false
export type IsNever<type> = [type] extends [never] ? true : false
/**
* Checks if {@link T} is `unknown`
* Checks if {@link type} is `unknown`
*
* @param T - Type to check
* @returns `true` if {@link T} is `unknown`, otherwise `false`
* @param type - Type to check
* @returns `true` if {@link type} is `unknown`, otherwise `false`
*

@@ -87,3 +93,3 @@ * @example

*/
export type IsUnknown<T> = unknown extends T ? true : false
export type IsUnknown<type> = unknown extends type ? true : false

@@ -93,4 +99,4 @@ /**

*
* @param T - Array to join
* @param U - Separator
* @param array - Array to join
* @param separator - Separator
* @returns string

@@ -103,8 +109,8 @@ *

export type Join<
T extends readonly unknown[],
U extends string | number,
> = T extends readonly [infer F, ...infer R]
? R['length'] extends 0
? `${F & string}`
: `${F & string}${U}${Join<R, U>}`
array extends readonly unknown[],
separator extends string | number,
> = array extends readonly [infer head, ...infer tail]
? tail['length'] extends 0
? `${head & string}`
: `${head & string}${separator}${Join<tail, separator>}`
: never

@@ -115,5 +121,5 @@

*
* @param Object1 - Object to merge into
* @param Object2 - Object to merge and override keys from {@link Object1}
* @returns New object type with keys from {@link Object1} and {@link Object2}. If a key exists in both {@link Object1} and {@link Object2}, the key from {@link Object2} will be used.
* @param object1 - Object to merge into
* @param object2 - Object to merge and override keys from {@link object1}
* @returns New object type with keys from {@link object1} and {@link object2}. If a key exists in both {@link object1} and {@link object2}, the key from {@link object2} will be used.
*

@@ -124,3 +130,3 @@ * @example

*/
export type Merge<Object1, Object2> = Omit<Object1, keyof Object2> & Object2
export type Merge<object1, object2> = Omit<object1, keyof object2> & object2

@@ -130,3 +136,3 @@ /**

*
* @param Union - Union to distribute.
* @param union - Union to distribute.
*

@@ -138,8 +144,9 @@ * @example

export type OneOf<
Union extends object,
AllKeys extends KeyofUnion<Union> = KeyofUnion<Union>,
> = Union extends infer Item
? Pretty<Item & { [K in Exclude<AllKeys, keyof Item>]?: never }>
union extends object,
///
allKeys extends KeyofUnion<union> = KeyofUnion<union>,
> = union extends infer item
? Pretty<item & { [key in Exclude<allKeys, keyof item>]?: never }>
: never
type KeyofUnion<T> = T extends T ? keyof T : never
type KeyofUnion<type> = type extends type ? keyof type : never

@@ -154,3 +161,3 @@ /**

*/
export type Pretty<T> = { [K in keyof T]: T[K] } & unknown
export type Pretty<type> = { [key in keyof type]: type[key] } & unknown

@@ -160,5 +167,5 @@ /**

*
* @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}
*

@@ -171,24 +178,25 @@ * @example

export 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>
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>
/**
* Trims empty space from type T.
* Trims empty space from type {@link t}.
*
* @param T - Type to trim
* @param Chars - Characters to trim
* @param t - Type to trim
* @param chars - Characters to trim
* @returns Trimmed type

@@ -200,19 +208,20 @@ *

*/
export type Trim<T, Chars extends string = ' '> = TrimLeft<
TrimRight<T, Chars>,
Chars
export type Trim<type, chars extends string = ' '> = TrimLeft<
TrimRight<type, chars>,
chars
>
type TrimLeft<T, Chars extends string = ' '> = T extends `${Chars}${infer R}`
? TrimLeft<R>
: T
type TrimRight<T, Chars extends string = ' '> = T extends `${infer R}${Chars}`
? TrimRight<R>
: T
type TrimLeft<t, chars extends string = ' '> = t extends `${chars}${infer tail}`
? TrimLeft<tail>
: t
type TrimRight<
t,
chars extends string = ' ',
> = t extends `${infer head}${chars}` ? TrimRight<head> : t
/**
* Create tuple of {@link Type} type with {@link Size} size
* Create tuple of {@link type} type with {@link size} size
*
* @param Type - Type of tuple
* @param Size - Size of tuple
* @returns Tuple of {@link Type} type with {@link Size} size
* @returns Tuple of {@link type} type with {@link size} size
*

@@ -224,13 +233,13 @@ * @example

// https://github.com/Microsoft/TypeScript/issues/26223#issuecomment-674500430
export type Tuple<Type, Size extends number> = Size extends Size
? number extends Size
? Type[]
: _TupleOf<Type, Size, []>
export type Tuple<type, size extends number> = size extends size
? number extends size
? type[]
: _TupleOf<type, size, []>
: never
type _TupleOf<
TNumber,
TSize extends number,
R extends readonly unknown[],
> = R['length'] extends TSize
? R
: _TupleOf<TNumber, TSize, readonly [TNumber, ...R]>
length,
size extends number,
acc extends readonly unknown[],
> = acc['length'] extends size
? acc
: _TupleOf<length, size, readonly [length, ...acc]>

414

src/utils.ts

@@ -26,14 +26,14 @@ import type {

*
* @param TAbiType - {@link AbiType} to convert to TypeScript representation
* @param TAbiParameterKind - Optional {@link AbiParameterKind} to narrow by parameter type
* @param abiType - {@link AbiType} to convert to TypeScript representation
* @param abiParameterKind - Optional {@link AbiParameterKind} to narrow by parameter type
* @returns TypeScript primitive type
*/
export type AbiTypeToPrimitiveType<
TAbiType extends AbiType,
TAbiParameterKind extends AbiParameterKind = AbiParameterKind,
> = TAbiType extends SolidityBytes
abiType extends AbiType,
abiParameterKind extends AbiParameterKind = AbiParameterKind,
> = abiType extends SolidityBytes
? // If PrimitiveTypeLookup is missing key values from AbiType,
// there will be an error on this property access
PrimitiveTypeLookup[TAbiType][TAbiParameterKind]
: PrimitiveTypeLookup[TAbiType]
PrimitiveTypeLookup[abiType][abiParameterKind]
: PrimitiveTypeLookup[abiType]

@@ -44,5 +44,5 @@ interface PrimitiveTypeLookup

SolidityArrayMap {
address: ResolvedRegister['AddressType']
address: ResolvedRegister['addressType']
bool: boolean
function: `${ResolvedRegister['AddressType']}${string}`
function: `${ResolvedRegister['addressType']}${string}`
string: string

@@ -55,4 +55,4 @@ tuple: Record<string, unknown>

| 'u'
| ''}int${infer TBits extends keyof BitsTypeLookup}`
? BitsTypeLookup[TBits]
| ''}int${infer bits extends keyof BitsTypeLookup}`
? BitsTypeLookup[bits]
: never

@@ -62,3 +62,3 @@ }

type SolidityByteMap = {
[_ in SolidityBytes]: ResolvedRegister['BytesType']
[_ in SolidityBytes]: ResolvedRegister['bytesType']
}

@@ -73,5 +73,5 @@

type BitsTypeLookup = {
[K in MBits]: ResolvedRegister[K extends LessThanOrEqualTo48Bits
? 'IntType'
: 'BigIntType']
[key in MBits]: ResolvedRegister[key extends LessThanOrEqualTo48Bits
? 'intType'
: 'bigIntType']
}

@@ -82,34 +82,34 @@

*
* @param TAbiParameter - {@link AbiParameter} to convert to TypeScript representation
* @param TAbiParameterKind - Optional {@link AbiParameterKind} to narrow by parameter type
* @param abiParameter - {@link AbiParameter} to convert to TypeScript representation
* @param abiParameterKind - Optional {@link AbiParameterKind} to narrow by parameter type
* @returns TypeScript primitive type
*/
export type AbiParameterToPrimitiveType<
TAbiParameter extends AbiParameter | { name: string; type: unknown },
TAbiParameterKind extends AbiParameterKind = AbiParameterKind,
abiParameter extends AbiParameter | { name: string; type: unknown },
abiParameterKind extends AbiParameterKind = AbiParameterKind,
// 1. Check to see if type is basic (not tuple or array) and can be looked up immediately.
> = TAbiParameter['type'] extends AbiBasicType
? AbiTypeToPrimitiveType<TAbiParameter['type'], TAbiParameterKind>
> = abiParameter['type'] extends AbiBasicType
? AbiTypeToPrimitiveType<abiParameter['type'], abiParameterKind>
: // 2. Check if type is tuple and covert each component
TAbiParameter extends {
type: SolidityTuple
components: infer TComponents extends readonly AbiParameter[]
}
? AbiComponentsToPrimitiveType<TComponents, TAbiParameterKind>
: // 3. Check if type is array.
MaybeExtractArrayParameterType<TAbiParameter['type']> extends [
infer Head extends string,
infer Size,
]
? AbiArrayToPrimitiveType<TAbiParameter, TAbiParameterKind, Head, Size>
: // 4. If type is not basic, tuple, or array, we don't know what the type is.
// This can happen when a fixed-length array is out of range (`Size` doesn't exist in `SolidityFixedArraySizeLookup`),
// the array has depth greater than `Config['ArrayMaxDepth']`, etc.
ResolvedRegister['StrictAbiType'] extends true
? Error<`Unknown type '${TAbiParameter['type'] & string}'.`>
: // 5. If we've gotten this far, let's check for errors in tuple components.
// (Happens for recursive tuple typed data types.)
TAbiParameter extends { components: Error<string> }
? TAbiParameter['components']
: unknown
abiParameter extends {
type: SolidityTuple
components: infer components extends readonly AbiParameter[]
}
? AbiComponentsToPrimitiveType<components, abiParameterKind>
: // 3. Check if type is array.
MaybeExtractArrayParameterType<abiParameter['type']> extends [
infer head extends string,
infer size,
]
? AbiArrayToPrimitiveType<abiParameter, abiParameterKind, head, size>
: // 4. If type is not basic, tuple, or array, we don't know what the type is.
// This can happen when a fixed-length array is out of range (`Size` doesn't exist in `SolidityFixedArraySizeLookup`),
// the array has depth greater than `ResolvedRegister['arrayMaxDepth']`, etc.
ResolvedRegister['strictAbiType'] extends true
? Error<`Unknown type '${abiParameter['type'] & string}'.`>
: // 5. If we've gotten this far, let's check for errors in tuple components.
// (Happens for recursive tuple typed data types.)
abiParameter extends { components: Error<string> }
? abiParameter['components']
: unknown

@@ -119,29 +119,28 @@ type AbiBasicType = Exclude<AbiType, SolidityTuple | SolidityArray>

type AbiComponentsToPrimitiveType<
Components extends readonly AbiParameter[],
TAbiParameterKind extends AbiParameterKind,
> = Components extends readonly []
components extends readonly AbiParameter[],
abiParameterKind extends AbiParameterKind,
> = components extends readonly []
? []
: // Compare the original set of names to a "validated"
// set where each name is coerced to a string and undefined|"" are excluded
Components[number]['name'] extends Exclude<
Components[number]['name'] & string,
undefined | ''
>
? // If all the original names are present, all tuple parameters are named so return as object
{
[Component in
Components[number] as Component['name'] & {}]: AbiParameterToPrimitiveType<
Component,
TAbiParameterKind
// set where each name is coerced to a string and undefined|"" are excluded
components[number]['name'] extends Exclude<
components[number]['name'] & string,
undefined | ''
>
}
: // Otherwise, has unnamed tuple parameters so return as array
{
[I in keyof Components]: AbiParameterToPrimitiveType<
Components[I],
TAbiParameterKind
>
}
? // If all the original names are present, all tuple parameters are named so return as object
{
[component in components[number] as component['name'] & {}]: AbiParameterToPrimitiveType<
component,
abiParameterKind
>
}
: // Otherwise, has unnamed tuple parameters so return as array
{
[key in keyof components]: AbiParameterToPrimitiveType<
components[key],
abiParameterKind
>
}
type MaybeExtractArrayParameterType<T> =
type MaybeExtractArrayParameterType<type> =
/**

@@ -155,12 +154,12 @@ * First, infer `Head` against a known size type (either fixed-length array value or `""`).

*/
T extends `${infer Head}[${'' | `${SolidityFixedArrayRange}`}]`
? // * Then, infer in the opposite direction, using the known `Head` to infer the exact `Size` value.
type extends `${infer head}[${'' | `${SolidityFixedArrayRange}`}]`
? // * Then, infer in the opposite direction, using the known `head` to infer the exact `size` value.
// *
// * | Input | Size |
// * | ------------ | ---- |
// * | `${Head}[]` | `""` |
// * | `${Head}[3]` | `3` |
// * | `${head}[]` | `""` |
// * | `${head}[3]` | `3` |
// */
T extends `${Head}[${infer Size}]`
? [Head, Size]
type extends `${head}[${infer size}]`
? [head, size]
: undefined

@@ -170,14 +169,14 @@ : undefined

type AbiArrayToPrimitiveType<
TAbiParameter extends AbiParameter | { name: string; type: unknown },
TAbiParameterKind extends AbiParameterKind,
Head extends string,
Size,
> = Size extends keyof SolidityFixedArraySizeLookup
abiParameter extends AbiParameter | { name: string; type: unknown },
abiParameterKind extends AbiParameterKind,
head extends string,
size,
> = size extends keyof SolidityFixedArraySizeLookup
? // Check if size is within range for fixed-length arrays, if so create a tuple.
Tuple<
AbiParameterToPrimitiveType<
Merge<TAbiParameter, { type: Head }>,
TAbiParameterKind
Merge<abiParameter, { type: head }>,
abiParameterKind
>,
SolidityFixedArraySizeLookup[Size]
SolidityFixedArraySizeLookup[size]
>

@@ -187,4 +186,4 @@ : // Otherwise, create an array. Tuples and arrays are created with `[${Size}]` popped off the end

readonly AbiParameterToPrimitiveType<
Merge<TAbiParameter, { type: Head }>,
TAbiParameterKind
Merge<abiParameter, { type: head }>,
abiParameterKind
>[]

@@ -195,9 +194,9 @@

*
* @param TAbiParameters - Array of {@link AbiParameter} to convert to TypeScript representations
* @param TAbiParameterKind - Optional {@link AbiParameterKind} to narrow by parameter type
* @param abiParameters - Array of {@link AbiParameter} to convert to TypeScript representations
* @param abiParameterKind - Optional {@link AbiParameterKind} to narrow by parameter type
* @returns Array of TypeScript primitive types
*/
export type AbiParametersToPrimitiveTypes<
TAbiParameters extends readonly AbiParameter[],
TAbiParameterKind extends AbiParameterKind = AbiParameterKind,
abiParameters extends readonly AbiParameter[],
abiParameterKind extends AbiParameterKind = AbiParameterKind,
> = Pretty<{

@@ -207,5 +206,5 @@ // TODO: Convert to labeled tuple so parameter names show up in autocomplete

// https://github.com/microsoft/TypeScript/issues/44939
[K in keyof TAbiParameters]: AbiParameterToPrimitiveType<
TAbiParameters[K],
TAbiParameterKind
[key in keyof abiParameters]: AbiParameterToPrimitiveType<
abiParameters[key],
abiParameterKind
>

@@ -217,6 +216,6 @@ }>

*
* @param TAbi - {@link Abi} to check
* @returns Boolean for whether {@link TAbi} is {@link Abi}
* @param abi - {@link Abi} to check
* @returns Boolean for whether {@link abi} is {@link Abi}
*/
export type IsAbi<TAbi> = TAbi extends Abi ? true : false
export type IsAbi<abi> = abi extends Abi ? true : false

@@ -229,12 +228,12 @@ ////////////////////////////////////////////////////////////////////////////////////////////////////

*
* @param TAbi - {@link Abi} to extract functions from
* @param TAbiStateMutability - {@link AbiStateMutability} to filter by
* @param abi - {@link Abi} to extract functions from
* @param abiStateMutability - {@link AbiStateMutability} to filter by
* @returns All {@link AbiFunction} types from {@link Abi}
*/
export type ExtractAbiFunctions<
TAbi extends Abi,
TAbiStateMutability extends AbiStateMutability = AbiStateMutability,
abi extends Abi,
abiStateMutability extends AbiStateMutability = AbiStateMutability,
> = Extract<
TAbi[number],
{ type: 'function'; stateMutability: TAbiStateMutability }
abi[number],
{ type: 'function'; stateMutability: abiStateMutability }
>

@@ -245,10 +244,10 @@

*
* @param TAbi - {@link Abi} to extract function names from
* @param TAbiStateMutability - {@link AbiStateMutability} to filter by
* @param abi - {@link Abi} to extract function names from
* @param abiStateMutability - {@link AbiStateMutability} to filter by
* @returns Union of function names
*/
export type ExtractAbiFunctionNames<
TAbi extends Abi,
TAbiStateMutability extends AbiStateMutability = AbiStateMutability,
> = ExtractAbiFunctions<TAbi, TAbiStateMutability>['name']
abi extends Abi,
abiStateMutability extends AbiStateMutability = AbiStateMutability,
> = ExtractAbiFunctions<abi, abiStateMutability>['name']

@@ -258,14 +257,14 @@ /**

*
* @param TAbi - {@link Abi} to extract {@link AbiFunction} from
* @param TFunctionName - String name of function to extract from {@link Abi}
* @param TAbiStateMutability - {@link AbiStateMutability} to filter by
* @param abi - {@link Abi} to extract {@link AbiFunction} from
* @param functionName - String name of function to extract from {@link Abi}
* @param abiStateMutability - {@link AbiStateMutability} to filter by
* @returns Matching {@link AbiFunction}
*/
export type ExtractAbiFunction<
TAbi extends Abi,
TFunctionName extends ExtractAbiFunctionNames<TAbi>,
TAbiStateMutability extends AbiStateMutability = AbiStateMutability,
abi extends Abi,
functionName extends ExtractAbiFunctionNames<abi>,
abiStateMutability extends AbiStateMutability = AbiStateMutability,
> = Extract<
ExtractAbiFunctions<TAbi, TAbiStateMutability>,
{ name: TFunctionName }
ExtractAbiFunctions<abi, abiStateMutability>,
{ name: functionName }
>

@@ -279,7 +278,7 @@

*
* @param TAbi - {@link Abi} to extract events from
* @param abi - {@link Abi} to extract events from
* @returns All {@link AbiEvent} types from {@link Abi}
*/
export type ExtractAbiEvents<TAbi extends Abi> = Extract<
TAbi[number],
export type ExtractAbiEvents<abi extends Abi> = Extract<
abi[number],
{ type: 'event' }

@@ -291,7 +290,7 @@ >

*
* @param TAbi - {@link Abi} to extract event names from
* @param abi - {@link Abi} to extract event names from
* @returns Union of event names
*/
export type ExtractAbiEventNames<TAbi extends Abi> =
ExtractAbiEvents<TAbi>['name']
export type ExtractAbiEventNames<abi extends Abi> =
ExtractAbiEvents<abi>['name']

@@ -301,10 +300,10 @@ /**

*
* @param TAbi - {@link Abi} to extract {@link AbiEvent} from
* @param TEventName - String name of event to extract from {@link Abi}
* @param abi - {@link Abi} to extract {@link AbiEvent} from
* @param eventName - String name of event to extract from {@link Abi}
* @returns Matching {@link AbiEvent}
*/
export type ExtractAbiEvent<
TAbi extends Abi,
TEventName extends ExtractAbiEventNames<TAbi>,
> = Extract<ExtractAbiEvents<TAbi>, { name: TEventName }>
abi extends Abi,
eventName extends ExtractAbiEventNames<abi>,
> = Extract<ExtractAbiEvents<abi>, { name: eventName }>

@@ -317,7 +316,7 @@ ////////////////////////////////////////////////////////////////////////////////////////////////////

*
* @param TAbi - {@link Abi} to extract errors from
* @param abi - {@link Abi} to extract errors from
* @returns All {@link AbiError} types from {@link Abi}
*/
export type ExtractAbiErrors<TAbi extends Abi> = Extract<
TAbi[number],
export type ExtractAbiErrors<abi extends Abi> = Extract<
abi[number],
{ type: 'error' }

@@ -329,7 +328,7 @@ >

*
* @param TAbi - {@link Abi} to extract error names from
* @param abi - {@link Abi} to extract error names from
* @returns Union of error names
*/
export type ExtractAbiErrorNames<TAbi extends Abi> =
ExtractAbiErrors<TAbi>['name']
export type ExtractAbiErrorNames<abi extends Abi> =
ExtractAbiErrors<abi>['name']

@@ -339,10 +338,10 @@ /**

*
* @param TAbi - {@link Abi} to extract {@link AbiError} from
* @param TErrorName - String name of error to extract from {@link Abi}
* @param abi - {@link Abi} to extract {@link AbiError} from
* @param errorName - String name of error to extract from {@link Abi}
* @returns Matching {@link AbiError}
*/
export type ExtractAbiError<
TAbi extends Abi,
TErrorName extends ExtractAbiErrorNames<TAbi>,
> = Extract<ExtractAbiErrors<TAbi>, { name: TErrorName }>
abi extends Abi,
errorName extends ExtractAbiErrorNames<abi>,
> = Extract<ExtractAbiErrors<abi>, { name: errorName }>

@@ -355,21 +354,20 @@ ////////////////////////////////////////////////////////////////////////////////////////////////////

*
* @param TTypedData - {@link TypedData} to check
* @returns Boolean for whether {@link TTypedData} is {@link TypedData}
* @param typedData - {@link TypedData} to check
* @returns Boolean for whether {@link typedData} is {@link TypedData}
*/
export type IsTypedData<TTypedData> = TTypedData extends TypedData
export type IsTypedData<typedData> = typedData extends TypedData
? {
[K in keyof TTypedData]: {
[key in keyof typedData]: {
// Map over typed data values and turn into key-value pairs.
// Valid types are set to `never` so we can weed out invalid types more easily.
[K2 in
TTypedData[K][number] as K2['type'] extends keyof TTypedData
[key2 in typedData[key][number] as key2['type'] extends keyof typedData
? never
: key2['type'] extends `${keyof typedData & string}[${string}]`
? never
: K2['type'] extends `${keyof TTypedData & string}[${string}]`
? never
: K2['type'] extends TypedDataType
? never
: K2['name']]: false
: key2['type'] extends TypedDataType
? never
: key2['name']]: false
}
} extends {
[K in keyof TTypedData]: Record<string, never>
[key in keyof typedData]: Record<string, never>
}

@@ -381,43 +379,43 @@ ? true

/**
* Converts {@link TTypedData} to corresponding TypeScript primitive types.
* Converts {@link typedData} to corresponding TypeScript primitive types.
*
* @param TTypedData - {@link TypedData} to convert
* @param TAbiParameterKind - Optional {@link AbiParameterKind} to narrow by parameter type
* @param typedData - {@link TypedData} to convert
* @param abiParameterKind - Optional {@link AbiParameterKind} to narrow by parameter type
* @returns Union of TypeScript primitive types
*/
export type TypedDataToPrimitiveTypes<
TTypedData extends TypedData,
TAbiParameterKind extends AbiParameterKind = AbiParameterKind,
TKeyReferences extends { [_: string]: unknown } | unknown = unknown,
typedData extends TypedData,
abiParameterKind extends AbiParameterKind = AbiParameterKind,
keyReferences extends { [_: string]: unknown } | unknown = unknown,
> = {
[K in keyof TTypedData]: {
[key in keyof typedData]: {
// Map over typed data values and turn into key-value pairs
[K2 in TTypedData[K][number] as K2['name']]: K2['type'] extends K // 1. Eliminate self-referencing structs
? Error<`Cannot convert self-referencing struct '${K2['type']}' to primitive type.`>
: K2['type'] extends keyof TTypedData // 2. Check if type is struct
? K2['type'] extends keyof TKeyReferences
? Error<`Circular reference detected. '${K2['type']}' is a circular reference.`>
: TypedDataToPrimitiveTypes<
Exclude<TTypedData, K>,
TAbiParameterKind,
TKeyReferences & { [_ in K2['type'] | K]: true }
>[K2['type']]
: // 3. Check if type is array of structs
K2['type'] extends `${infer TType extends keyof TTypedData &
string}[${infer Tail}]`
? AbiParameterToPrimitiveType<
{
name: K2['name']
type: `tuple[${Tail}]`
components: _TypedDataParametersToAbiParameters<
TTypedData[TType],
TTypedData,
TKeyReferences & { [_ in TType | K]: true }
[key2 in typedData[key][number] as key2['name']]: key2['type'] extends key // 1. Eliminate self-referencing structs
? Error<`Cannot convert self-referencing struct '${key2['type']}' to primitive type.`>
: key2['type'] extends keyof typedData // 2. Check if type is struct
? key2['type'] extends keyof keyReferences
? Error<`Circular reference detected. '${key2['type']}' is a circular reference.`>
: TypedDataToPrimitiveTypes<
Exclude<typedData, key>,
abiParameterKind,
keyReferences & { [_ in key2['type'] | key]: true }
>[key2['type']]
: // 3. Check if type is array of structs
key2['type'] extends `${infer type extends keyof typedData &
string}[${infer tail}]`
? AbiParameterToPrimitiveType<
{
name: key2['name']
type: `tuple[${tail}]`
components: _TypedDataParametersToAbiParameters<
typedData[type],
typedData,
keyReferences & { [_ in type | key]: true }
>
},
abiParameterKind
>
},
TAbiParameterKind
>
: K2['type'] extends TypedDataType // 4. Known type to convert
? AbiParameterToPrimitiveType<K2, TAbiParameterKind>
: Error<`Cannot convert unknown type '${K2['type']}' to primitive type.`>
: key2['type'] extends TypedDataType // 4. Known type to convert
? AbiParameterToPrimitiveType<key2, abiParameterKind>
: Error<`Cannot convert unknown type '${key2['type']}' to primitive type.`>
}

@@ -428,42 +426,42 @@ // Ensure the result is "Prettied"

type _TypedDataParametersToAbiParameters<
TTypedDataParameters extends readonly TypedDataParameter[],
TTypedData extends TypedData,
TKeyReferences extends { [_: string]: unknown } | unknown = unknown,
typedDataParameters extends readonly TypedDataParameter[],
typedData extends TypedData,
keyReferences extends { [_: string]: unknown } | unknown = unknown,
> = {
// Map over typed data parameters and convert into ABI parameters
[K in
keyof TTypedDataParameters]: TTypedDataParameters[K] extends infer TTypedDataParameter extends {
name: string
type: unknown
}
[key in keyof typedDataParameters]: typedDataParameters[key] extends infer typedDataParameter extends
{
name: string
type: unknown
}
? // 1. Check if type is struct
TTypedDataParameter['type'] extends keyof TTypedData & string
typedDataParameter['type'] extends keyof typedData & string
? {
name: TTypedDataParameter['name']
name: typedDataParameter['name']
type: 'tuple'
components: TTypedDataParameter['type'] extends keyof TKeyReferences
? Error<`Circular reference detected. '${TTypedDataParameter['type']}' is a circular reference.`>
components: typedDataParameter['type'] extends keyof keyReferences
? Error<`Circular reference detected. '${typedDataParameter['type']}' is a circular reference.`>
: _TypedDataParametersToAbiParameters<
TTypedData[TTypedDataParameter['type']],
TTypedData,
TKeyReferences & { [_ in TTypedDataParameter['type']]: true }
typedData[typedDataParameter['type']],
typedData,
keyReferences & { [_ in typedDataParameter['type']]: true }
>
}
: // 2. Check if type is array of structs
TTypedDataParameter['type'] extends `${infer TType extends keyof TTypedData &
string}[${infer Tail}]`
? {
name: TTypedDataParameter['name']
type: `tuple[${Tail}]`
components: TType extends keyof TKeyReferences
? Error<`Circular reference detected. '${TTypedDataParameter['type']}' is a circular reference.`>
: _TypedDataParametersToAbiParameters<
TTypedData[TType],
TTypedData,
TKeyReferences & { [_ in TType]: true }
>
}
: // 3. Type is already ABI parameter
TTypedDataParameter
typedDataParameter['type'] extends `${infer type extends
keyof typedData & string}[${infer tail}]`
? {
name: typedDataParameter['name']
type: `tuple[${tail}]`
components: type extends keyof keyReferences
? Error<`Circular reference detected. '${typedDataParameter['type']}' is a circular reference.`>
: _TypedDataParametersToAbiParameters<
typedData[type],
typedData,
keyReferences & { [_ in type]: true }
>
}
: // 3. Type is already ABI parameter
typedDataParameter
: never
}

2

src/version.ts

@@ -1,1 +0,1 @@

export const version = '0.0.0-canary.20240315T081554'
export const version = '0.0.0-canary-20240620192132'
dist/cjs/errors.js.map

Sorry, the diff of this file is not supported yet

dist/cjs/human-readable/formatAbi.js.map

Sorry, the diff of this file is not supported yet

dist/cjs/human-readable/formatAbiItem.js.map

Sorry, the diff of this file is not supported yet

dist/cjs/human-readable/formatAbiParameter.js.map

Sorry, the diff of this file is not supported yet

dist/cjs/human-readable/formatAbiParameters.js.map

Sorry, the diff of this file is not supported yet

dist/cjs/human-readable/parseAbi.js.map

Sorry, the diff of this file is not supported yet

dist/cjs/human-readable/parseAbiItem.js.map

Sorry, the diff of this file is not supported yet

dist/cjs/human-readable/parseAbiParameter.js.map

Sorry, the diff of this file is not supported yet

dist/cjs/human-readable/parseAbiParameters.js.map

Sorry, the diff of this file is not supported yet

dist/cjs/human-readable/runtime/cache.js.map

Sorry, the diff of this file is not supported yet

dist/cjs/human-readable/runtime/signatures.js.map

Sorry, the diff of this file is not supported yet

dist/cjs/human-readable/runtime/structs.js.map

Sorry, the diff of this file is not supported yet

dist/cjs/human-readable/runtime/utils.js.map

Sorry, the diff of this file is not supported yet

dist/cjs/narrow.js.map

Sorry, the diff of this file is not supported yet

dist/cjs/regex.js.map

Sorry, the diff of this file is not supported yet

dist/cjs/version.js.map

Sorry, the diff of this file is not supported yet

dist/cjs/zod.js.map

Sorry, the diff of this file is not supported yet

dist/esm/errors.js.map

Sorry, the diff of this file is not supported yet

dist/esm/human-readable/formatAbi.js.map

Sorry, the diff of this file is not supported yet

dist/esm/human-readable/formatAbiItem.js.map

Sorry, the diff of this file is not supported yet

dist/esm/human-readable/formatAbiParameter.js.map

Sorry, the diff of this file is not supported yet

dist/esm/human-readable/formatAbiParameters.js.map

Sorry, the diff of this file is not supported yet

dist/esm/human-readable/parseAbi.js.map

Sorry, the diff of this file is not supported yet

dist/esm/human-readable/parseAbiItem.js.map

Sorry, the diff of this file is not supported yet

dist/esm/human-readable/parseAbiParameter.js.map

Sorry, the diff of this file is not supported yet

dist/esm/human-readable/parseAbiParameters.js.map

Sorry, the diff of this file is not supported yet

dist/esm/human-readable/runtime/structs.js.map

Sorry, the diff of this file is not supported yet

dist/esm/human-readable/runtime/utils.js.map

Sorry, the diff of this file is not supported yet

dist/esm/narrow.js.map

Sorry, the diff of this file is not supported yet

dist/esm/regex.js.map

Sorry, the diff of this file is not supported yet

dist/esm/version.js.map

Sorry, the diff of this file is not supported yet

dist/esm/zod.js.map

Sorry, the diff of this file is not supported yet

dist/types/abi.d.ts.map

Sorry, the diff of this file is not supported yet

dist/types/human-readable/formatAbi.d.ts.map

Sorry, the diff of this file is not supported yet

dist/types/human-readable/formatAbiItem.d.ts.map

Sorry, the diff of this file is not supported yet

dist/types/human-readable/formatAbiParameter.d.ts.map

Sorry, the diff of this file is not supported yet

dist/types/human-readable/formatAbiParameters.d.ts.map

Sorry, the diff of this file is not supported yet

dist/types/human-readable/parseAbi.d.ts.map

Sorry, the diff of this file is not supported yet

dist/types/human-readable/parseAbiItem.d.ts.map

Sorry, the diff of this file is not supported yet

dist/types/human-readable/parseAbiParameter.d.ts.map

Sorry, the diff of this file is not supported yet

dist/types/human-readable/parseAbiParameters.d.ts.map

Sorry, the diff of this file is not supported yet

dist/types/human-readable/runtime/signatures.d.ts.map

Sorry, the diff of this file is not supported yet

dist/types/human-readable/types/signatures.d.ts.map

Sorry, the diff of this file is not supported yet

dist/types/human-readable/types/structs.d.ts.map

Sorry, the diff of this file is not supported yet

dist/types/human-readable/types/utils.d.ts.map

Sorry, the diff of this file is not supported yet

dist/types/narrow.d.ts.map

Sorry, the diff of this file is not supported yet

dist/types/regex.d.ts.map

Sorry, the diff of this file is not supported yet

dist/types/register.d.ts.map

Sorry, the diff of this file is not supported yet

dist/types/types.d.ts.map

Sorry, the diff of this file is not supported yet

dist/types/utils.d.ts.map

Sorry, the diff of this file is not supported yet

dist/types/version.d.ts.map

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc