/**

readonly name?: string;

/**

readonly indexed?: boolean;

/**

readonly type?: string;

/**

readonly internalType?: string;

/**

readonly components?: ReadonlyArray<JsonFragmentType>;

/**

readonly name?: string;

/**

readonly type?: string;

/**

readonly anonymous?: boolean;

/**

readonly payable?: boolean;

/**

readonly constant?: boolean;

/**

readonly stateMutability?: string;

/**

readonly inputs?: ReadonlyArray<JsonFragmentType>;

/**

readonly outputs?: ReadonlyArray<JsonFragmentType>;

/**

readonly gas?: string;

const result: Set<string> = new Set();

items.forEach((k) => result.add(k));

return Object.freeze(result);

// Type of token (e.g. TYPE, KEYWORD, NUMBER, etc)

type: string;

// Offset into the original source code

offset: number;

// Actual text content of the token

text: string;

// The parenthesis depth

depth: number;

// If a parenthesis, the offset (in tokens) that balances it

match: number;

// For parenthesis and commas, the offset (in tokens) to the

// previous/next parenthesis or comma in the list

linkBack: number;

linkNext: number;

// If a BRACKET, the value inside

value: number;

#offset: number;

#tokens: ReadonlyArray<Token>;

get offset(): number { return this.#offset; }

get length(): number { return this.#tokens.length - this.#offset; }

constructor(tokens: ReadonlyArray<Token>) {

this.#offset = 0;

this.#tokens = tokens.slice();

}

clone(): TokenString { return new TokenString(this.#tokens); }

reset(): void { this.#offset = 0; }

#subTokenString(from: number = 0, to: number = 0): TokenString {

return new TokenString(this.#tokens.slice(from, to).map((t) => {

return Object.freeze(Object.assign({ }, t, {

match: (t.match - from),

linkBack: (t.linkBack - from),

linkNext: (t.linkNext - from),

}));

}));

}

// Pops and returns the value of the next token, if it is a keyword in allowed; throws if out of tokens

popKeyword(allowed: ReadonlySet<string>): string {

const top = this.peek();

if (top.type !== "KEYWORD" || !allowed.has(top.text)) { throw new Error(`expected keyword ${ top.text }`); }

return this.pop().text;

}

// Pops and returns the value of the next token if it is `type`; throws if out of tokens

popType(type: string): string {

if (this.peek().type !== type) {

const top = this.peek();

throw new Error(`expected ${ type }; got ${ top.type } ${ JSON.stringify(top.text) }`);

}

return this.pop().text;

}

// Pops and returns a "(" TOKENS ")"

popParen(): TokenString {

const top = this.peek();

if (top.type !== "OPEN_PAREN") { throw new Error("bad start"); }

const result = this.#subTokenString(this.#offset + 1, top.match + 1);

this.#offset = top.match + 1;

return result;

}

// Pops and returns the items within "(" ITEM1 "," ITEM2 "," ... ")"

popParams(): Array<TokenString> {

const top = this.peek();

if (top.type !== "OPEN_PAREN") { throw new Error("bad start"); }

const result: Array<TokenString> = [ ];

while(this.#offset < top.match - 1) {

const link = this.peek().linkNext;

result.push(this.#subTokenString(this.#offset + 1, link));

this.#offset = link;

}

this.#offset = top.match + 1;

return result;

}

// Returns the top Token, throwing if out of tokens

peek(): Token {

if (this.#offset >= this.#tokens.length) {

throw new Error("out-of-bounds");

}

return this.#tokens[this.#offset];

}

// Returns the next value, if it is a keyword in `allowed`

peekKeyword(allowed: ReadonlySet<string>): null | string {

const top = this.peekType("KEYWORD");

return (top != null && allowed.has(top)) ? top: null;

}

// Returns the value of the next token if it is `type`

peekType(type: string): null | string {

if (this.length === 0) { return null; }

const top = this.peek();

return (top.type === type) ? top.text: null;

}

// Returns the next token; throws if out of tokens

pop(): Token {

const result = this.peek();

this.#offset++;

return result;

}

toString(): string {

const tokens: Array<string> = [ ];

for (let i = this.#offset; i < this.#tokens.length; i++) {

const token = this.#tokens[i];

tokens.push(`${ token.type }:${ token.text }`);

}

return `<TokenString ${ tokens.join(" ") }>`

}

const tokens: Array<Token> = [ ];

const throwError = (message: string) => {

const token = (offset < text.length) ? JSON.stringify(text[offset]): "$EOI";

throw new Error(`invalid token ${ token } at ${ offset }: ${ message }`);

};

let brackets: Array<number> = [ ];

let commas: Array<number> = [ ];

let offset = 0;

while (offset < text.length) {

// Strip off any leading whitespace

let cur = text.substring(offset);

let match = cur.match(regexWhitespacePrefix);

if (match) {

offset += match[1].length;

cur = text.substring(offset);

}

const token = { depth: brackets.length, linkBack: -1, linkNext: -1, match: -1, type: "", text: "", offset, value: -1 };

tokens.push(token);

let type = (SimpleTokens[cur[0]] || "");

if (type) {

token.type = type;

token.text = cur[0];

offset++;

if (type === "OPEN_PAREN") {

brackets.push(tokens.length - 1);

commas.push(tokens.length - 1);

} else if (type == "CLOSE_PAREN") {

if (brackets.length === 0) { throwError("no matching open bracket"); }

token.match = brackets.pop() as number;

(<Writeable<Token>>(tokens[token.match])).match = tokens.length - 1;

token.depth--;

token.linkBack = commas.pop() as number;

(<Writeable<Token>>(tokens[token.linkBack])).linkNext = tokens.length - 1;

} else if (type === "COMMA") {

token.linkBack = commas.pop() as number;

(<Writeable<Token>>(tokens[token.linkBack])).linkNext = tokens.length - 1;

commas.push(tokens.length - 1);

} else if (type === "OPEN_BRACKET") {

token.type = "BRACKET";

} else if (type === "CLOSE_BRACKET") {

// Remove the CLOSE_BRACKET

let suffix = (tokens.pop() as Token).text;

if (tokens.length > 0 && tokens[tokens.length - 1].type === "NUMBER") {

const value = (tokens.pop() as Token).text;

suffix = value + suffix;

(<Writeable<Token>>(tokens[tokens.length - 1])).value = getNumber(value);

}

if (tokens.length === 0 || tokens[tokens.length - 1].type !== "BRACKET") {

throw new Error("missing opening bracket");

}

(<Writeable<Token>>(tokens[tokens.length - 1])).text += suffix;

}

continue;

}

match = cur.match(regexIdPrefix);

if (match) {

token.text = match[1];

offset += token.text.length;

if (Keywords.has(token.text)) {

token.type = "KEYWORD";

continue;

}

if (token.text.match(regexType)) {

token.type = "TYPE";

continue;

}

token.type = "ID";

continue;

}

match = cur.match(regexNumberPrefix);

if (match) {

token.text = match[1];

token.type = "NUMBER";

offset += token.text.length;

continue;

}

throw new Error(`unexpected token ${ JSON.stringify(cur[0]) } at position ${ offset }`);

}

return new TokenString(tokens.map((t) => Object.freeze(t)));

let included: Array<string> = [ ];

for (const key in allowed.keys()) {

if (set.has(key)) { included.push(key); }

}

if (included.length > 1) { throw new Error(`conflicting types: ${ included.join(", ") }`); }

if (tokens.peekKeyword(KwTypes)) {

const keyword = tokens.pop().text;

if (keyword !== type) {

throw new Error(`expected ${ type }, got ${ keyword }`);

}

}

return tokens.popType("ID");

const keywords: Set<string> = new Set();

while (true) {

const keyword = tokens.peekType("KEYWORD");

if (keyword == null || (allowed && !allowed.has(keyword))) { break; }

tokens.pop();

if (keywords.has(keyword)) { throw new Error(`duplicate keywords: ${ JSON.stringify(keyword) }`); }

keywords.add(keyword);

}

return Object.freeze(keywords);

let modifiers = consumeKeywords(tokens, KwVisib);

// Detect conflicting modifiers

allowSingle(modifiers, setify("constant payable nonpayable".split(" ")));

allowSingle(modifiers, setify("pure view payable nonpayable".split(" ")));

// Process mutability states

if (modifiers.has("view")) { return "view"; }

if (modifiers.has("pure")) { return "pure"; }

if (modifiers.has("payable")) { return "payable"; }

if (modifiers.has("nonpayable")) { return "nonpayable"; }

// Process legacy `constant` last

if (modifiers.has("constant")) { return "view"; }

return "nonpayable";

if (tokens.peekType("AT")) {

tokens.pop();

if (tokens.peekType("NUMBER")) {

return getBigInt(tokens.pop().text);

}

throw new Error("invalid gas");

}

return null;

if (tokens.length) {

throw new Error(`unexpected tokens at offset ${ tokens.offset }: ${ tokens.toString() }`);

}

const match = type.match(regexType);

assertArgument(match, "invalid type", "type", type);

if (type === "uint") { return "uint256"; }

if (type === "int") { return "int256"; }

if (match[2]) {

// bytesXX

const length = parseInt(match[2]);

assertArgument(length !== 0 && length <= 32, "invalid bytes length", "type", type);

} else if (match[3]) {

// intXX or uintXX

const size = parseInt(match[3] as string);

assertArgument(size !== 0 && size <= 256 && (size % 8) === 0, "invalid numeric width", "type", type);

}

return type;

/**

readonly name!: string;

/**

readonly type!: string;

/**

readonly baseType!: string;

/**

readonly indexed!: null | boolean;

/**

readonly components!: null | ReadonlyArray<ParamType>;

/**

readonly arrayLength!: null | number;

/**

readonly arrayChildren!: null | ParamType;

/**

constructor(guard: any, name: string, type: string, baseType: string, indexed: null | boolean, components: null | ReadonlyArray<ParamType>, arrayLength: null | number, arrayChildren: null | ParamType) {

assertPrivate(guard, _guard, "ParamType");

Object.defineProperty(this, internal, { value: ParamTypeInternal });

if (components) { components = Object.freeze(components.slice()); }

if (baseType === "array") {

if (arrayLength == null || arrayChildren == null) {

throw new Error("");

}

} else if (arrayLength != null || arrayChildren != null) {

throw new Error("");

}

if (baseType === "tuple") {

if (components == null) { throw new Error(""); }

} else if (components != null) {

throw new Error("");

}

defineProperties<ParamType>(this, {

name, type, baseType, indexed, components, arrayLength, arrayChildren

});

}

/**

format(format?: FormatType): string {

if (format == null) { format = "sighash"; }

if (format === "json") {

const name = this.name || "";

if (this.isArray()) {

const result = JSON.parse(this.arrayChildren.format("json"));

result.name = name;

result.type += `[${ (this.arrayLength < 0 ? "": String(this.arrayLength)) }]`;

return JSON.stringify(result);

}

const result: any = {

type: ((this.baseType === "tuple") ? "tuple": this.type),

name

};

if (typeof(this.indexed) === "boolean") { result.indexed = this.indexed; }

if (this.isTuple()) {

result.components = this.components.map((c) => JSON.parse(c.format(format)));

}

return JSON.stringify(result);

}

let result = "";

// Array

if (this.isArray()) {

result += this.arrayChildren.format(format);

result += `[${ (this.arrayLength < 0 ? "": String(this.arrayLength)) }]`;

} else {

if (this.isTuple()) {

result += "(" + this.components.map(

(comp) => comp.format(format)

).join((format === "full") ? ", ": ",") + ")";

} else {

result += this.type;

}

}

if (format !== "sighash") {

if (this.indexed === true) { result += " indexed"; }

if (format === "full" && this.name) {

result += " " + this.name;

}

}

return result;

}

/**

isArray(): this is (ParamType & { arrayChildren: ParamType, arrayLength: number }) {

return (this.baseType === "array")

}

/**

isTuple(): this is (ParamType & { components: ReadonlyArray<ParamType> }) {

return (this.baseType === "tuple");

}

/**

isIndexable(): this is (ParamType & { indexed: boolean }) {

return (this.indexed != null);

}

/**

walk(value: any, process: ParamTypeWalkFunc): any {

if (this.isArray()) {

if (!Array.isArray(value)) { throw new Error("invalid array value"); }

if (this.arrayLength !== -1 && value.length !== this.arrayLength) {

throw new Error("array is wrong length");

}

const _this = this;

return value.map((v) => (_this.arrayChildren.walk(v, process)));

}

if (this.isTuple()) {

if (!Array.isArray(value)) { throw new Error("invalid tuple value"); }

if (value.length !== this.components.length) {

throw new Error("array is wrong length");

}

const _this = this;

return value.map((v, i) => (_this.components[i].walk(v, process)));

}

return process(this.type, value);

}

#walkAsync(promises: Array<Promise<void>>, value: any, process: ParamTypeWalkAsyncFunc, setValue: (value: any) => void): void {

if (this.isArray()) {

if (!Array.isArray(value)) { throw new Error("invalid array value"); }

if (this.arrayLength !== -1 && value.length !== this.arrayLength) {

throw new Error("array is wrong length");

}

const childType = this.arrayChildren;

const result = value.slice();

result.forEach((value, index) => {

childType.#walkAsync(promises, value, process, (value: any) => {

result[index] = value;

});

});

setValue(result);

return;

}

if (this.isTuple()) {

const components = this.components;

// Convert the object into an array

let result: Array<any>;

if (Array.isArray(value)) {

result = value.slice();

} else {

if (value == null || typeof(value) !== "object") {

throw new Error("invalid tuple value");

}

result = components.map((param) => {

if (!param.name) { throw new Error("cannot use object value with unnamed components"); }

if (!(param.name in value)) {

throw new Error(`missing value for component ${ param.name }`);

}

return value[param.name];

});

}

if (result.length !== this.components.length) {

throw new Error("array is wrong length");

}

result.forEach((value, index) => {

components[index].#walkAsync(promises, value, process, (value: any) => {

result[index] = value;

});

});

setValue(result);

return;

}

const result = process(this.type, value);

if (result.then) {

promises.push((async function() { setValue(await result); })());

} else {

setValue(result);

}

}

/**

async walkAsync(value: any, process: ParamTypeWalkAsyncFunc): Promise<any> {

const promises: Array<Promise<void>> = [ ];

const result: [ any ] = [ value ];

this.#walkAsync(promises, value, process, (value: any) => {

result[0] = value;

});

if (promises.length) { await Promise.all(promises); }

return result[0];

}

/**

static from(obj: any, allowIndexed?: boolean): ParamType {

if (ParamType.isParamType(obj)) { return obj; }