Skip to content

Commit

Permalink
fix: bug fixes && small refactor
Browse files Browse the repository at this point in the history
  • Loading branch information
@Raiden1411
Raiden1411 committed May 19, 2023
1 parent acfab54 commit 3e688f0
Show file tree
Hide file tree
Showing 6 changed files with 1,016 additions and 931 deletions.
42 changes: 21 additions & 21 deletions src/config.test-d.ts
View file
Original file line number Diff line number Diff line change
@@ -1,34 +1,34 @@
import { assertType, test } from 'vitest'
import { assertType, test } from "vitest";

import type { ResolvedConfig } from './config.js'
import type { ResolvedConfig } from "./config.js";

// For testing updates to config properties:
// declare module './config.js' {
// declare module "./config.js" {
// export interface Config {
// Strict: true
// Strict: true;
// }
// }

test('Config', () => {
assertType<ResolvedConfig['ArrayMaxDepth']>(false)
assertType<ResolvedConfig['FixedArrayMinLength']>(1)
assertType<ResolvedConfig['FixedArrayMaxLength']>(99)
test("Config", () => {
assertType<ResolvedConfig["ArrayMaxDepth"]>(false);
assertType<ResolvedConfig["FixedArrayMinLength"]>(1);
assertType<ResolvedConfig["FixedArrayMaxLength"]>(99);

type AddressType = ResolvedConfig['AddressType']
assertType<AddressType>('0x0000000000000000000000000000000000000000')
type AddressType = ResolvedConfig["AddressType"];
assertType<AddressType>("0x0000000000000000000000000000000000000000");

type BytesType = ResolvedConfig['BytesType']
type BytesType = ResolvedConfig["BytesType"];
assertType<BytesType>({
inputs: '0xfoobarbaz',
outputs: '0xfoobarbaz',
})
inputs: "0xfoobarbaz",
outputs: "0xfoobarbaz",
});

type IntType = ResolvedConfig['IntType']
assertType<IntType>(123)
type IntType = ResolvedConfig["IntType"];
assertType<IntType>(123);

type BigIntType = ResolvedConfig['BigIntType']
assertType<BigIntType>(123n)
type BigIntType = ResolvedConfig["BigIntType"];
assertType<BigIntType>(123n);

type Strict = ResolvedConfig['Strict']
assertType<Strict>(false)
})
type Strict = ResolvedConfig["Strict"];
assertType<Strict>(false);
});
62 changes: 31 additions & 31 deletions src/human-readable/parseAbiParameter.ts
View file
Original file line number Diff line number Diff line change
@@ -1,36 +1,36 @@
import type { AbiParameter } from '../abi.js'
import type { Narrow } from '../narrow.js'
import type { Error, Filter, IsEmptyObject } from '../types.js'
import { InvalidAbiParameterError } from './errors/index.js'
import type { AbiParameter } from "../abi.js";
import type { Narrow } from "../narrow.js";
import type { Error, Filter, IsArrayString, IsEmptyObject } from "../types.js";
import { InvalidAbiParameterError } from "./errors/index.js";
import {
isStructSignature,
modifiers,
parseAbiParameter as parseAbiParameter_,
parseStructs,
} from './runtime/index.js'
} from "./runtime/index.js";
import type {
IsStructSignature,
Modifier,
ParseAbiParameter as ParseAbiParameter_,
ParseStructs,
} from './types/index.js'
} from "./types/index.js";

export type ValidateAbiParameter<TParams extends readonly string[]> =
ParseStructs<TParams> extends infer ParsedStructs extends object
? IsEmptyObject<ParsedStructs> extends true
? Error<'No Struct signature found. Please provide valid struct signatures.'>
? Error<"No Struct signature found. Please provide valid struct signatures.">
: {
[K in keyof TParams]: IsStructSignature<TParams[K]> extends true
? never
: TParams[K] extends `${infer Type} ${string}`
? Type extends keyof ParsedStructs
? IsArrayString<Type> extends keyof ParsedStructs
? never
: Error<`Invalid Parameter "${TParams[K]}". Only Struct parameters are allowed`>
: TParams[K] extends keyof ParsedStructs
: IsArrayString<TParams[K]> extends keyof ParsedStructs
? never
: Error<`Invalid Parameter "${TParams[K]}". Only Struct parameters are allowed`>
: Error<`Invalid Parameter "${TParams[K]}". Only Struct parameters are allowed`>;
}
: unknown
: unknown;

/**
* Parses human-readable ABI parameter into {@link AbiParameter}
Expand All @@ -49,10 +49,10 @@ export type ValidateAbiParameter<TParams extends readonly string[]> =
* >
*/
export type ParseAbiParameter<
TParam extends string | readonly string[] | readonly unknown[],
TParam extends string | readonly string[] | readonly unknown[]
> =
| (TParam extends string
? TParam extends ''
? TParam extends ""
? never
: string extends TParam
? AbiParameter
Expand All @@ -72,7 +72,7 @@ export type ParseAbiParameter<
TParam[K],
{ Modifier: Modifier; Structs: Structs }
>
: never
: never;
} extends infer Mapped extends readonly unknown[]
? Filter<Mapped, never>[0] extends infer Result
? Result extends undefined
Expand All @@ -83,7 +83,7 @@ export type ParseAbiParameter<
: never
: never
: never
: never)
: never);

/**
* Parses human-readable ABI parameter into {@link AbiParameter}
Expand All @@ -103,18 +103,18 @@ export type ParseAbiParameter<
* ])
*/
export function parseAbiParameter<
TParam extends string | readonly string[] | readonly unknown[],
TParam extends string | readonly string[] | readonly unknown[]
>(
param: Narrow<TParam> &
(
| (TParam extends string
? TParam extends ''
? Error<'Empty string is not allowed.'>
? TParam extends ""
? Error<"Empty string is not allowed.">
: unknown
: never)
| (TParam extends readonly string[]
? TParam extends readonly [] // empty array
? Error<'At least one parameter required.'>
? Error<"At least one parameter required.">
: string[] extends TParam
? unknown
: ValidateAbiParameter<TParam> extends infer ValidatedParams extends readonly unknown[]
Expand All @@ -123,25 +123,25 @@ export function parseAbiParameter<
: ValidatedParams
: never
: never)
),
)
): ParseAbiParameter<TParam> {
let abiParameter
if (typeof param === 'string')
let abiParameter;
if (typeof param === "string")
abiParameter = parseAbiParameter_(param, {
modifiers,
}) as ParseAbiParameter<TParam>
}) as ParseAbiParameter<TParam>;
else {
const structs = parseStructs(param as readonly string[])
const length = param.length as number
const structs = parseStructs(param as readonly string[]);
const length = param.length as number;
for (let i = 0; i < length; i++) {
const signature = (param as readonly string[])[i]!
if (isStructSignature(signature)) continue
abiParameter = parseAbiParameter_(signature, { modifiers, structs })
break
const signature = (param as readonly string[])[i]!;
if (isStructSignature(signature)) continue;
abiParameter = parseAbiParameter_(signature, { modifiers, structs });
break;
}
}

if (!abiParameter) throw new InvalidAbiParameterError({ param })
if (!abiParameter) throw new InvalidAbiParameterError({ param });

return abiParameter as ParseAbiParameter<TParam>
return abiParameter as ParseAbiParameter<TParam>;
}
72 changes: 38 additions & 34 deletions src/human-readable/parseAbiParameters.ts
View file
Original file line number Diff line number Diff line change
@@ -1,27 +1,31 @@
import type { AbiParameter } from '../abi.js'
import type { Narrow } from '../narrow.js'
import type { Error, Filter, Flatten } from '../types.js'
import type { ExtractAbiParseErrors } from '../utils.js'
import { InvalidAbiParametersError } from './errors/index.js'
import type { AbiParameter } from "../abi.js";
import type { Narrow } from "../narrow.js";
import type { Error, Filter, Flatten, IsEmptyObject } from "../types.js";
import type { ExtractAbiParseErrors } from "../utils.js";
import { InvalidAbiParametersError } from "./errors/index.js";
import {
isStructSignature,
modifiers,
parseAbiParameter as parseAbiParameter_,
parseStructs,
splitParameters,
} from './runtime/index.js'
} from "./runtime/index.js";
import type {
IsStructSignature,
Modifier,
ParseAbiParameters as ParseAbiParameters_,
ParseStructs,
SplitParameters,
} from './types/index.js'
} from "./types/index.js";

export type ValidateAbiParameters<T extends readonly string[]> =
ParseAbiParameters<T> extends infer ParsedParams extends readonly unknown[]
? Flatten<ExtractAbiParseErrors<ParsedParams>>
: never
ParseStructs<T> extends infer Structs extends object
? IsEmptyObject<Structs> extends true
? Error<"No Struct signature found. Please provide valid struct signatures.">
: ParseAbiParameters<T> extends infer ParsedParams extends readonly unknown[]
? Flatten<ExtractAbiParseErrors<ParsedParams>>
: never
: never;
/**
* Parses human-readable ABI parameters into {@link AbiParameter}s
*
Expand All @@ -39,10 +43,10 @@ export type ValidateAbiParameters<T extends readonly string[]> =
* >
*/
export type ParseAbiParameters<
TParams extends string | readonly string[] | readonly unknown[],
TParams extends string | readonly string[] | readonly unknown[]
> =
| (TParams extends string
? TParams extends ''
? TParams extends ""
? never
: string extends TParams
? readonly AbiParameter[]
Expand All @@ -60,7 +64,7 @@ export type ParseAbiParameters<
SplitParameters<TParams[K]>,
{ Modifier: Modifier; Structs: Structs }
>
: never
: never;
} extends infer Mapped extends readonly unknown[]
? Filter<Mapped, never>[0] extends infer Result
? Result extends undefined
Expand All @@ -69,7 +73,7 @@ export type ParseAbiParameters<
: never
: never
: never
: never)
: never);

/**
* Parses human-readable ABI parameters into {@link AbiParameter}s
Expand All @@ -89,18 +93,18 @@ export type ParseAbiParameters<
* ])
*/
export function parseAbiParameters<
TParams extends string | readonly string[] | readonly unknown[],
TParams extends string | readonly string[] | readonly unknown[]
>(
params: Narrow<TParams> &
(
| (TParams extends string
? TParams extends ''
? Error<'Empty string is not allowed.'>
? TParams extends ""
? Error<"Empty string is not allowed.">
: unknown
: never)
| (TParams extends readonly string[]
? TParams extends readonly [] // empty array
? Error<'At least one parameter required.'>
? Error<"At least one parameter required.">
: string[] extends TParams
? unknown
: ValidateAbiParameters<TParams> extends infer Parsed
Expand All @@ -111,33 +115,33 @@ export function parseAbiParameters<
: Parsed
: never
: never)
),
)
): ParseAbiParameters<TParams> {
const abiParameters: AbiParameter[] = []
if (typeof params === 'string') {
const parameters = splitParameters(params)
const length = parameters.length
const abiParameters: AbiParameter[] = [];
if (typeof params === "string") {
const parameters = splitParameters(params);
const length = parameters.length;
for (let i = 0; i < length; i++) {
abiParameters.push(parseAbiParameter_(parameters[i]!, { modifiers }))
abiParameters.push(parseAbiParameter_(parameters[i]!, { modifiers }));
}
} else {
const structs = parseStructs(params as readonly string[])
const length = params.length as number
const structs = parseStructs(params as readonly string[]);
const length = params.length as number;
for (let i = 0; i < length; i++) {
const signature = (params as readonly string[])[i]!
if (isStructSignature(signature)) continue
const parameters = splitParameters(signature)
const length = parameters.length
const signature = (params as readonly string[])[i]!;
if (isStructSignature(signature)) continue;
const parameters = splitParameters(signature);
const length = parameters.length;
for (let k = 0; k < length; k++) {
abiParameters.push(
parseAbiParameter_(parameters[k]!, { modifiers, structs }),
)
parseAbiParameter_(parameters[k]!, { modifiers, structs })
);
}
}
}

if (abiParameters.length === 0)
throw new InvalidAbiParametersError({ params })
throw new InvalidAbiParametersError({ params });

return abiParameters as ParseAbiParameters<TParams>
return abiParameters as ParseAbiParameters<TParams>;
}
Loading

0 comments on commit 3e688f0

Please sign in to comment.