PHP WebShell
Текущая директория: /var/www/bitcardoApp/node_modules/tronweb/src/utils
Просмотр файла: interface.ts
/**
* The Interface class is a low-level class that accepts an
* ABI and provides all the necessary functionality to encode
* and decode paramaters to and results from methods, events
* and errors.
*
* It also provides several convenience methods to automatically
* search and find matching transactions and events to parse them.
*
* @_subsection api/abi:Interfaces [interfaces]
*/
import { keccak256 } from 'ethers';
import { id } from 'ethers';
import {
concat,
dataSlice,
getBigInt,
getBytes,
getBytesCopy,
hexlify,
zeroPadValue,
isHexString,
defineProperties,
assertArgument,
toBeHex,
assert,
} from 'ethers';
import { AbiCoder } from 'ethers';
import { checkResultErrors, Result } from 'ethers';
import {
ConstructorFragment,
ErrorFragment,
EventFragment,
FallbackFragment,
Fragment,
FunctionFragment,
ParamType,
} from './fragments.js';
import { Typed } from 'ethers';
import type { BigNumberish, BytesLike, CallExceptionError, CallExceptionTransaction } from 'ethers';
import type { JsonFragment } from 'ethers';
export { checkResultErrors, Result };
/**
* When using the [[Interface-parseLog]] to automatically match a Log to its event
* for parsing, a **LogDescription** is returned.
*/
export class LogDescription {
/**
* The matching fragment for the ``topic0``.
*/
readonly fragment!: EventFragment;
/**
* The name of the Event.
*/
readonly name!: string;
/**
* The full Event signature.
*/
readonly signature!: string;
/**
* The topic hash for the Event.
*/
readonly topic!: string;
/**
* The arguments passed into the Event with ``emit``.
*/
readonly args!: Result;
/**
* @_ignore:
*/
constructor(fragment: EventFragment, topic: string, args: Result) {
const name = fragment.name,
signature = fragment.format();
defineProperties<LogDescription>(this, {
fragment,
name,
signature,
topic,
args,
});
}
}
/**
* When using the [[Interface-parseTransaction]] to automatically match
* a transaction data to its function for parsing,
* a **TransactionDescription** is returned.
*/
export class TransactionDescription {
/**
* The matching fragment from the transaction ``data``.
*/
readonly fragment!: FunctionFragment;
/**
* The name of the Function from the transaction ``data``.
*/
readonly name!: string;
/**
* The arguments passed to the Function from the transaction ``data``.
*/
readonly args!: Result;
/**
* The full Function signature from the transaction ``data``.
*/
readonly signature!: string;
/**
* The selector for the Function from the transaction ``data``.
*/
readonly selector!: string;
/**
* The ``value`` (in wei) from the transaction.
*/
readonly value!: bigint;
/**
* @_ignore:
*/
constructor(fragment: FunctionFragment, selector: string, args: Result, value: bigint) {
const name = fragment.name,
signature = fragment.format();
defineProperties<TransactionDescription>(this, {
fragment,
name,
args,
signature,
selector,
value,
});
}
}
/**
* When using the [[Interface-parseError]] to automatically match an
* error for a call result for parsing, an **ErrorDescription** is returned.
*/
export class ErrorDescription {
/**
* The matching fragment.
*/
readonly fragment!: ErrorFragment;
/**
* The name of the Error.
*/
readonly name!: string;
/**
* The arguments passed to the Error with ``revert``.
*/
readonly args!: Result;
/**
* The full Error signature.
*/
readonly signature!: string;
/**
* The selector for the Error.
*/
readonly selector!: string;
/**
* @_ignore:
*/
constructor(fragment: ErrorFragment, selector: string, args: Result) {
const name = fragment.name,
signature = fragment.format();
defineProperties<ErrorDescription>(this, {
fragment,
name,
args,
signature,
selector,
});
}
}
/**
* An **Indexed** is used as a value when a value that does not
* fit within a topic (i.e. not a fixed-length, 32-byte type). It
* is the ``keccak256`` of the value, and used for types such as
* arrays, tuples, bytes and strings.
*/
export class Indexed {
/**
* The ``keccak256`` of the value logged.
*/
readonly hash!: null | string;
/**
* @_ignore:
*/
readonly _isIndexed!: boolean;
/**
* Returns ``true`` if %%value%% is an **Indexed**.
*
* This provides a Type Guard for property access.
*/
static isIndexed(value: any): value is Indexed {
return !!(value && value._isIndexed);
}
/**
* @_ignore:
*/
constructor(hash: null | string) {
defineProperties<Indexed>(this, { hash, _isIndexed: true });
}
}
type ErrorInfo = {
signature: string;
inputs: Array<string>;
name: string;
reason: (...args: Array<any>) => string;
};
// https://docs.soliditylang.org/en/v0.8.13/control-structures.html?highlight=panic#panic-via-assert-and-error-via-require
const PanicReasons: Record<string, string> = {
'0': 'generic panic',
'1': 'assert(false)',
'17': 'arithmetic overflow',
'18': 'division or modulo by zero',
'33': 'enum overflow',
'34': 'invalid encoded storage byte array accessed',
'49': 'out-of-bounds array access; popping on an empty array',
'50': 'out-of-bounds access of an array or bytesN',
'65': 'out of memory',
'81': 'uninitialized function',
};
const BuiltinErrors: Record<string, ErrorInfo> = {
'0x08c379a0': {
signature: 'Error(string)',
name: 'Error',
inputs: ['string'],
reason: (message: string) => {
return `reverted with reason string ${JSON.stringify(message)}`;
},
},
'0x4e487b71': {
signature: 'Panic(uint256)',
name: 'Panic',
inputs: ['uint256'],
reason: (code: bigint) => {
let reason = 'unknown panic code';
if (code >= 0 && code <= 0xff && PanicReasons[code.toString()]) {
reason = PanicReasons[code.toString()];
}
return `reverted with panic code 0x${code.toString(16)} (${reason})`;
},
},
};
/*
function wrapAccessError(property: string, error: Error): Error {
const wrap = new Error(`deferred error during ABI decoding triggered accessing ${ property }`);
(<any>wrap).error = error;
return wrap;
}
*/
/*
function checkNames(fragment: Fragment, type: "input" | "output", params: Array<ParamType>): void {
params.reduce((accum, param) => {
if (param.name) {
if (accum[param.name]) {
logger.throwArgumentError(`duplicate ${ type } parameter ${ JSON.stringify(param.name) } in ${ fragment.format("full") }`, "fragment", fragment);
}
accum[param.name] = true;
}
return accum;
}, <{ [ name: string ]: boolean }>{ });
}
*/
/**
* An **InterfaceAbi** may be any supported ABI format.
*
* A string is expected to be a JSON string, which will be parsed
* using ``JSON.parse``. This means that the value **must** be a valid
* JSON string, with no stray commas, etc.
*
* An array may contain any combination of:
* - Human-Readable fragments
* - Parsed JSON fragment
* - [[Fragment]] instances
*
* A **Human-Readable Fragment** is a string which resembles a Solidity
* signature and is introduced in [this blog entry](link-ricmoo-humanreadableabi).
* For example, ``function balanceOf(address) view returns (uint)``.
*
* A **Parsed JSON Fragment** is a JavaScript Object desribed in the
* [Solidity documentation](link-solc-jsonabi).
*/
export type InterfaceAbi = string | ReadonlyArray<Fragment | JsonFragment | string>;
/**
* An Interface abstracts many of the low-level details for
* encoding and decoding the data on the blockchain.
*
* An ABI provides information on how to encode data to send to
* a Contract, how to decode the results and events and how to
* interpret revert errors.
*
* The ABI can be specified by [any supported format](InterfaceAbi).
*/
export class Interface {
/**
* All the Contract ABI members (i.e. methods, events, errors, etc).
*/
readonly fragments!: ReadonlyArray<Fragment>;
/**
* The Contract constructor.
*/
readonly deploy!: ConstructorFragment;
/**
* The Fallback method, if any.
*/
readonly fallback!: null | FallbackFragment;
/**
* If receiving ether is supported.
*/
readonly receive!: boolean;
#errors: Map<string, ErrorFragment>;
#events: Map<string, EventFragment>;
#functions: Map<string, FunctionFragment>;
// #structs: Map<string, StructFragment>;
#abiCoder: AbiCoder;
/**
* Create a new Interface for the %%fragments%%.
*/
constructor(fragments: InterfaceAbi) {
let abi: ReadonlyArray<Fragment | JsonFragment | string> = [];
if (typeof fragments === 'string') {
abi = JSON.parse(fragments);
} else {
abi = fragments;
}
this.#functions = new Map();
this.#errors = new Map();
this.#events = new Map();
// this.#structs = new Map();
const frags: Array<Fragment> = [];
for (const a of abi) {
try {
frags.push(Fragment.from(a));
} catch (error) {
console.log('EE', error);
}
}
defineProperties<Interface>(this, {
fragments: Object.freeze(frags),
});
let fallback: null | FallbackFragment = null;
let receive = false;
this.#abiCoder = this.getAbiCoder();
// Add all fragments by their signature
this.fragments.forEach((fragment, index) => {
let bucket: Map<string, Fragment>;
switch (fragment.type) {
case 'constructor':
if (this.deploy) {
console.log('duplicate definition - constructor');
return;
}
//checkNames(fragment, "input", fragment.inputs);
defineProperties<Interface>(this, {
deploy: <ConstructorFragment>fragment,
});
return;
case 'fallback':
if (fragment.inputs.length === 0) {
receive = true;
} else {
assertArgument(
!fallback || (<FallbackFragment>fragment).payable !== fallback.payable,
'conflicting fallback fragments',
`fragments[${index}]`,
fragment
);
fallback = <FallbackFragment>fragment;
receive = fallback.payable;
}
return;
case 'function':
//checkNames(fragment, "input", fragment.inputs);
//checkNames(fragment, "output", (<FunctionFragment>fragment).outputs);
bucket = this.#functions;
break;
case 'event':
//checkNames(fragment, "input", fragment.inputs);
bucket = this.#events;
break;
case 'error':
bucket = this.#errors;
break;
default:
return;
}
// Two identical entries; ignore it
const signature = fragment.format();
if (bucket.has(signature)) {
return;
}
bucket.set(signature, fragment);
});
// If we do not have a constructor add a default
if (!this.deploy) {
defineProperties<Interface>(this, {
deploy: ConstructorFragment.from('constructor()'),
});
}
defineProperties<Interface>(this, { fallback, receive });
}
/**
* Returns the entire Human-Readable ABI, as an array of
* signatures, optionally as %%minimal%% strings, which
* removes parameter names and unneceesary spaces.
*/
format(minimal?: boolean): Array<string> {
const format = minimal ? 'minimal' : 'full';
const abi = this.fragments.map((f) => f.format(format));
return abi;
}
/**
* Return the JSON-encoded ABI. This is the format Solidiy
* returns.
*/
formatJson(): string {
const abi = this.fragments.map((f) => f.format('json'));
// We need to re-bundle the JSON fragments a bit
return JSON.stringify(abi.map((j) => JSON.parse(j)));
}
/**
* The ABI coder that will be used to encode and decode binary
* data.
*/
getAbiCoder(): AbiCoder {
return AbiCoder.defaultAbiCoder();
}
// Find a function definition by any means necessary (unless it is ambiguous)
#getFunction(key: string, values: null | Array<any | Typed>, forceUnique: boolean): null | FunctionFragment {
// Selector
if (isHexString(key)) {
const selector = key.toLowerCase();
for (const fragment of this.#functions.values()) {
if (selector === fragment.selector) {
return fragment;
}
}
return null;
}
// It is a bare name, look up the function (will return null if ambiguous)
if (key.indexOf('(') === -1) {
const matching: Array<FunctionFragment> = [];
for (const [name, fragment] of this.#functions) {
if (name.split('(' /* fix:) */)[0] === key) {
matching.push(fragment);
}
}
if (values) {
const lastValue = values.length > 0 ? values[values.length - 1] : null;
let valueLength = values.length;
let allowOptions = true;
if (Typed.isTyped(lastValue) && lastValue.type === 'overrides') {
allowOptions = false;
valueLength--;
}
// Remove all matches that don't have a compatible length. The args
// may contain an overrides, so the match may have n or n - 1 parameters
for (let i = matching.length - 1; i >= 0; i--) {
const inputs = matching[i].inputs.length;
if (inputs !== valueLength && (!allowOptions || inputs !== valueLength - 1)) {
matching.splice(i, 1);
}
}
// Remove all matches that don't match the Typed signature
for (let i = matching.length - 1; i >= 0; i--) {
const inputs = matching[i].inputs;
for (let j = 0; j < values.length; j++) {
// Not a typed value
if (!Typed.isTyped(values[j])) {
continue;
}
// We are past the inputs
if (j >= inputs.length) {
if (values[j].type === 'overrides') {
continue;
}
matching.splice(i, 1);
break;
}
// Make sure the value type matches the input type
if (values[j].type !== inputs[j].baseType) {
matching.splice(i, 1);
break;
}
}
}
}
// We found a single matching signature with an overrides, but the
// last value is something that cannot possibly be an options
if (matching.length === 1 && values && values.length !== matching[0].inputs.length) {
const lastArg = values[values.length - 1];
if (lastArg == null || Array.isArray(lastArg) || typeof lastArg !== 'object') {
matching.splice(0, 1);
}
}
if (matching.length === 0) {
return null;
}
if (matching.length > 1 && forceUnique) {
const matchStr = matching.map((m) => JSON.stringify(m.format())).join(', ');
assertArgument(false, `ambiguous function description (i.e. matches ${matchStr})`, 'key', key);
}
return matching[0];
}
// Normalize the signature and lookup the function
const result = this.#functions.get(FunctionFragment.from(key).format());
if (result) {
return result;
}
return null;
}
/**
* Get the function name for %%key%%, which may be a function selector,
* function name or function signature that belongs to the ABI.
*/
getFunctionName(key: string): string {
const fragment = this.#getFunction(key, null, false);
assertArgument(fragment, 'no matching function', 'key', key);
return fragment.name;
}
/**
* Returns true if %%key%% (a function selector, function name or
* function signature) is present in the ABI.
*
* In the case of a function name, the name may be ambiguous, so
* accessing the [[FunctionFragment]] may require refinement.
*/
hasFunction(key: string): boolean {
return !!this.#getFunction(key, null, false);
}
/**
* Get the [[FunctionFragment]] for %%key%%, which may be a function
* selector, function name or function signature that belongs to the ABI.
*
* If %%values%% is provided, it will use the Typed API to handle
* ambiguous cases where multiple functions match by name.
*
* If the %%key%% and %%values%% do not refine to a single function in
* the ABI, this will throw.
*/
getFunction(key: string, values?: Array<any | Typed>): null | FunctionFragment {
return this.#getFunction(key, values || null, true);
}
/**
* Iterate over all functions, calling %%callback%%, sorted by their name.
*/
forEachFunction(callback: (func: FunctionFragment, index: number) => void): void {
const names = Array.from(this.#functions.keys());
names.sort((a, b) => a.localeCompare(b));
for (let i = 0; i < names.length; i++) {
const name = names[i];
callback(<FunctionFragment>this.#functions.get(name), i);
}
}
// Find an event definition by any means necessary (unless it is ambiguous)
#getEvent(key: string, values: null | Array<null | any | Typed>, forceUnique: boolean): null | EventFragment {
// EventTopic
if (isHexString(key)) {
const eventTopic = key.toLowerCase();
for (const fragment of this.#events.values()) {
if (eventTopic === fragment.topicHash) {
return fragment;
}
}
return null;
}
// It is a bare name, look up the function (will return null if ambiguous)
if (key.indexOf('(') === -1) {
const matching: EventFragment[] = [];
for (const [name, fragment] of this.#events) {
if (name.split('(' /* fix:) */)[0] === key) {
matching.push(fragment);
}
}
if (values) {
// Remove all matches that don't have a compatible length.
for (let i = matching.length - 1; i >= 0; i--) {
if (matching[i].inputs.length < values.length) {
matching.splice(i, 1);
}
}
// Remove all matches that don't match the Typed signature
for (let i = matching.length - 1; i >= 0; i--) {
const inputs = matching[i].inputs;
for (let j = 0; j < values.length; j++) {
// Not a typed value
if (!Typed.isTyped(values[j])) {
continue;
}
// Make sure the value type matches the input type
if (values[j].type !== inputs[j].baseType) {
matching.splice(i, 1);
break;
}
}
}
}
if (matching.length === 0) {
return null;
}
if (matching.length > 1 && forceUnique) {
const matchStr = matching.map((m) => JSON.stringify(m.format())).join(', ');
assertArgument(false, `ambiguous event description (i.e. matches ${matchStr})`, 'key', key);
}
return matching[0];
}
// Normalize the signature and lookup the function
const result = this.#events.get(EventFragment.from(key).format());
if (result) {
return result;
}
return null;
}
/**
* Get the event name for %%key%%, which may be a topic hash,
* event name or event signature that belongs to the ABI.
*/
getEventName(key: string): string {
const fragment = this.#getEvent(key, null, false);
assertArgument(fragment, 'no matching event', 'key', key);
return fragment.name;
}
/**
* Returns true if %%key%% (an event topic hash, event name or
* event signature) is present in the ABI.
*
* In the case of an event name, the name may be ambiguous, so
* accessing the [[EventFragment]] may require refinement.
*/
hasEvent(key: string): boolean {
return !!this.#getEvent(key, null, false);
}
/**
* Get the [[EventFragment]] for %%key%%, which may be a topic hash,
* event name or event signature that belongs to the ABI.
*
* If %%values%% is provided, it will use the Typed API to handle
* ambiguous cases where multiple events match by name.
*
* If the %%key%% and %%values%% do not refine to a single event in
* the ABI, this will throw.
*/
getEvent(key: string, values?: Array<any | Typed>): null | EventFragment {
return this.#getEvent(key, values || null, true);
}
/**
* Iterate over all events, calling %%callback%%, sorted by their name.
*/
forEachEvent(callback: (func: EventFragment, index: number) => void): void {
const names = Array.from(this.#events.keys());
names.sort((a, b) => a.localeCompare(b));
for (let i = 0; i < names.length; i++) {
const name = names[i];
callback(<EventFragment>this.#events.get(name), i);
}
}
/**
* Get the [[ErrorFragment]] for %%key%%, which may be an error
* selector, error name or error signature that belongs to the ABI.
*
* If %%values%% is provided, it will use the Typed API to handle
* ambiguous cases where multiple errors match by name.
*
* If the %%key%% and %%values%% do not refine to a single error in
* the ABI, this will throw.
*/
getError(key: string, values?: Array<any | Typed>): null | ErrorFragment {
if (isHexString(key)) {
const selector = key.toLowerCase();
if (BuiltinErrors[selector]) {
return ErrorFragment.from(BuiltinErrors[selector].signature);
}
for (const fragment of this.#errors.values()) {
if (selector === fragment.selector) {
return fragment;
}
}
return null;
}
// It is a bare name, look up the function (will return null if ambiguous)
if (key.indexOf('(') === -1) {
const matching: ErrorFragment[] = [];
for (const [name, fragment] of this.#errors) {
if (name.split('(' /* fix:) */)[0] === key) {
matching.push(fragment);
}
}
if (matching.length === 0) {
if (key === 'Error') {
return ErrorFragment.from('error Error(string)');
}
if (key === 'Panic') {
return ErrorFragment.from('error Panic(uint256)');
}
return null;
} else if (matching.length > 1) {
const matchStr = matching.map((m) => JSON.stringify(m.format())).join(', ');
assertArgument(false, `ambiguous error description (i.e. ${matchStr})`, 'name', key);
}
return matching[0];
}
// Normalize the signature and lookup the function
key = ErrorFragment.from(key).format();
if (key === 'Error(string)') {
return ErrorFragment.from('error Error(string)');
}
if (key === 'Panic(uint256)') {
return ErrorFragment.from('error Panic(uint256)');
}
const result = this.#errors.get(key);
if (result) {
return result;
}
return null;
}
/**
* Iterate over all errors, calling %%callback%%, sorted by their name.
*/
forEachError(callback: (func: ErrorFragment, index: number) => void): void {
const names = Array.from(this.#errors.keys());
names.sort((a, b) => a.localeCompare(b));
for (let i = 0; i < names.length; i++) {
const name = names[i];
callback(<ErrorFragment>this.#errors.get(name), i);
}
}
// Get the 4-byte selector used by Solidity to identify a function
/*
getSelector(fragment: ErrorFragment | FunctionFragment): string {
if (typeof(fragment) === "string") {
const matches: Array<Fragment> = [ ];
try { matches.push(this.getFunction(fragment)); } catch (error) { }
try { matches.push(this.getError(<string>fragment)); } catch (_) { }
if (matches.length === 0) {
logger.throwArgumentError("unknown fragment", "key", fragment);
} else if (matches.length > 1) {
logger.throwArgumentError("ambiguous fragment matches function and error", "key", fragment);
}
fragment = matches[0];
}
return dataSlice(id(fragment.format()), 0, 4);
}
*/
// Get the 32-byte topic hash used by Solidity to identify an event
/*
getEventTopic(fragment: EventFragment): string {
//if (typeof(fragment) === "string") { fragment = this.getEvent(eventFragment); }
return id(fragment.format());
}
*/
_decodeParams(params: ReadonlyArray<ParamType | string>, data: BytesLike): Result {
return this.#abiCoder.decode(params as any, data);
}
_encodeParams(params: ReadonlyArray<ParamType>, values: ReadonlyArray<any>): string {
return this.#abiCoder.encode(params as any, values);
}
/**
* Encodes a ``tx.data`` object for deploying the Contract with
* the %%values%% as the constructor arguments.
*/
encodeDeploy(values?: ReadonlyArray<any>): string {
return this._encodeParams(this.deploy.inputs, values || []);
}
/**
* Decodes the result %%data%% (e.g. from an ``eth_call``) for the
* specified error (see [[getError]] for valid values for
* %%key%%).
*
* Most developers should prefer the [[parseCallResult]] method instead,
* which will automatically detect a ``CALL_EXCEPTION`` and throw the
* corresponding error.
*/
decodeErrorResult(fragment: ErrorFragment | string, data: BytesLike): Result {
if (typeof fragment === 'string') {
const f = this.getError(fragment);
assertArgument(f, 'unknown error', 'fragment', fragment);
fragment = f;
}
assertArgument(
dataSlice(data, 0, 4) === fragment.selector,
`data signature does not match error ${fragment.name}.`,
'data',
data
);
return this._decodeParams(fragment.inputs, dataSlice(data, 4));
}
/**
* Encodes the transaction revert data for a call result that
* reverted from the the Contract with the sepcified %%error%%
* (see [[getError]] for valid values for %%fragment%%) with the %%values%%.
*
* This is generally not used by most developers, unless trying to mock
* a result from a Contract.
*/
encodeErrorResult(fragment: ErrorFragment | string, values?: ReadonlyArray<any>): string {
if (typeof fragment === 'string') {
const f = this.getError(fragment);
assertArgument(f, 'unknown error', 'fragment', fragment);
fragment = f;
}
return concat([fragment.selector, this._encodeParams(fragment.inputs, values || [])]);
}
/**
* Decodes the %%data%% from a transaction ``tx.data`` for
* the function specified (see [[getFunction]] for valid values
* for %%fragment%%).
*
* Most developers should prefer the [[parseTransaction]] method
* instead, which will automatically detect the fragment.
*/
decodeFunctionData(fragment: FunctionFragment | string, data: BytesLike): Result {
if (typeof fragment === 'string') {
const f = this.getFunction(fragment);
assertArgument(f, 'unknown function', 'fragment', fragment);
fragment = f;
}
assertArgument(
dataSlice(data, 0, 4) === fragment.selector,
`data signature does not match function ${fragment.name}.`,
'data',
data
);
return this._decodeParams(fragment.inputs, dataSlice(data, 4));
}
/**
* Encodes the ``tx.data`` for a transaction that calls the function
* specified (see [[getFunction]] for valid values for %%fragment%%) with
* the %%values%%.
*/
encodeFunctionData(fragment: FunctionFragment | string, values?: ReadonlyArray<any>): string {
if (typeof fragment === 'string') {
const f = this.getFunction(fragment);
assertArgument(f, 'unknown function', 'fragment', fragment);
fragment = f;
}
return concat([fragment.selector, this._encodeParams(fragment.inputs, values || [])]);
}
/**
* Decodes the result %%data%% (e.g. from an ``eth_call``) for the
* specified function (see [[getFunction]] for valid values for
* %%key%%).
*
* Most developers should prefer the [[parseCallResult]] method instead,
* which will automatically detect a ``CALL_EXCEPTION`` and throw the
* corresponding error.
*/
decodeFunctionResult(fragment: FunctionFragment | string, data: BytesLike): Result {
if (typeof fragment === 'string') {
const f = this.getFunction(fragment);
assertArgument(f, 'unknown function', 'fragment', fragment);
fragment = f;
}
let message = 'invalid length for result data';
const bytes = getBytesCopy(data);
if (bytes.length % 32 === 0) {
try {
return this.#abiCoder.decode(fragment.outputs as any, bytes);
} catch (error) {
message = 'could not decode result data';
}
}
// Call returned data with no error, but the data is junk
assert(false, message, 'BAD_DATA', {
value: hexlify(bytes),
info: { method: fragment.name, signature: fragment.format() },
});
}
makeError(_data: BytesLike, tx: CallExceptionTransaction): CallExceptionError {
const data = getBytes(_data, 'data');
const error = AbiCoder.getBuiltinCallException('call', tx, data);
// Not a built-in error; try finding a custom error
const customPrefix = 'execution reverted (unknown custom error)';
if (error.message.startsWith(customPrefix)) {
const selector = hexlify(data.slice(0, 4));
const ef = this.getError(selector);
if (ef) {
try {
const args = this.#abiCoder.decode(ef.inputs as any, data.slice(4));
error.revert = {
name: ef.name,
signature: ef.format(),
args,
};
error.reason = error.revert.signature;
error.message = `execution reverted: ${error.reason}`;
} catch (e) {
error.message = `execution reverted (coult not decode custom error)`;
}
}
}
// Add the invocation, if available
const parsed = this.parseTransaction(tx);
if (parsed) {
error.invocation = {
method: parsed.name,
signature: parsed.signature,
args: parsed.args,
};
}
return error;
}
/**
* Encodes the result data (e.g. from an ``eth_call``) for the
* specified function (see [[getFunction]] for valid values
* for %%fragment%%) with %%values%%.
*
* This is generally not used by most developers, unless trying to mock
* a result from a Contract.
*/
encodeFunctionResult(fragment: FunctionFragment | string, values?: ReadonlyArray<any>): string {
if (typeof fragment === 'string') {
const f = this.getFunction(fragment);
assertArgument(f, 'unknown function', 'fragment', fragment);
fragment = f;
}
return hexlify(this.#abiCoder.encode(fragment.outputs as any, values || []));
}
/*
spelunk(inputs: Array<ParamType>, values: ReadonlyArray<any>, processfunc: (type: string, value: any) => Promise<any>): Promise<Array<any>> {
const promises: Array<Promise<>> = [ ];
const process = function(type: ParamType, value: any): any {
if (type.baseType === "array") {
return descend(type.child
}
if (type. === "address") {
}
};
const descend = function (inputs: Array<ParamType>, values: ReadonlyArray<any>) {
if (inputs.length !== values.length) { throw new Error("length mismatch"); }
};
const result: Array<any> = [ ];
values.forEach((value, index) => {
if (value == null) {
topics.push(null);
} else if (param.baseType === "array" || param.baseType === "tuple") {
logger.throwArgumentError("filtering with tuples or arrays not supported", ("contract." + param.name), value);
} else if (Array.isArray(value)) {
topics.push(value.map((value) => encodeTopic(param, value)));
} else {
topics.push(encodeTopic(param, value));
}
});
}
*/
// Create the filter for the event with search criteria (e.g. for eth_filterLog)
encodeFilterTopics(fragment: EventFragment | string, values: ReadonlyArray<any>): Array<null | string | Array<string>> {
if (typeof fragment === 'string') {
const f = this.getEvent(fragment);
assertArgument(f, 'unknown event', 'eventFragment', fragment);
fragment = f;
}
assert(values.length <= fragment.inputs.length, `too many arguments for ${fragment.format()}`, 'UNEXPECTED_ARGUMENT', {
count: values.length,
expectedCount: fragment.inputs.length,
});
const topics: Array<null | string | Array<string>> = [];
if (!fragment.anonymous) {
topics.push(fragment.topicHash);
}
// @TODO: Use the coders for this; to properly support tuples, etc.
const encodeTopic = (param: ParamType, value: any): string => {
if (param.type === 'string') {
return id(value);
} else if (param.type === 'bytes') {
return keccak256(hexlify(value));
}
if (param.type === 'bool' && typeof value === 'boolean') {
value = value ? '0x01' : '0x00';
}
if (param.type.match(/^u?int/)) {
value = toBeHex(value);
}
// Check addresses are valid
if (param.type === 'address') {
this.#abiCoder.encode(['address'], [value]);
}
return zeroPadValue(hexlify(value), 32);
//@TOOD should probably be return toHex(value, 32)
};
values.forEach((value, index) => {
const param = (<EventFragment>fragment).inputs[index];
if (!param.indexed) {
assertArgument(
value == null,
'cannot filter non-indexed parameters; must be null',
'contract.' + param.name,
value
);
return;
}
if (value == null) {
topics.push(null);
} else if (param.baseType === 'array' || param.baseType === 'tuple') {
assertArgument(false, 'filtering with tuples or arrays not supported', 'contract.' + param.name, value);
} else if (Array.isArray(value)) {
topics.push(value.map((value) => encodeTopic(param, value)));
} else {
topics.push(encodeTopic(param, value));
}
});
// Trim off trailing nulls
while (topics.length && topics[topics.length - 1] === null) {
topics.pop();
}
return topics;
}
encodeEventLog(fragment: EventFragment | string, values: ReadonlyArray<any>): { data: string; topics: Array<string> } {
if (typeof fragment === 'string') {
const f = this.getEvent(fragment);
assertArgument(f, 'unknown event', 'eventFragment', fragment);
fragment = f;
}
const topics: Array<string> = [];
const dataTypes: Array<ParamType> = [];
const dataValues: Array<string> = [];
if (!fragment.anonymous) {
topics.push(fragment.topicHash);
}
assertArgument(values.length === fragment.inputs.length, 'event arguments/values mismatch', 'values', values);
fragment.inputs.forEach((param, index) => {
const value = values[index];
if (param.indexed) {
if (param.type === 'string') {
topics.push(id(value));
} else if (param.type === 'bytes') {
topics.push(keccak256(value));
} else if (param.baseType === 'tuple' || param.baseType === 'array') {
// @TODO
throw new Error('not implemented');
} else {
topics.push(this.#abiCoder.encode([param.type], [value]));
}
} else {
dataTypes.push(param);
dataValues.push(value);
}
});
return {
data: this.#abiCoder.encode(dataTypes as any, dataValues),
topics: topics,
};
}
// Decode a filter for the event and the search criteria
decodeEventLog(fragment: EventFragment | string, data: BytesLike, topics?: ReadonlyArray<string>): Result {
if (typeof fragment === 'string') {
const f = this.getEvent(fragment);
assertArgument(f, 'unknown event', 'eventFragment', fragment);
fragment = f;
}
if (topics != null && !fragment.anonymous) {
const eventTopic = fragment.topicHash;
assertArgument(
isHexString(topics[0], 32) && topics[0].toLowerCase() === eventTopic,
'fragment/topic mismatch',
'topics[0]',
topics[0]
);
topics = topics.slice(1);
}
const indexed: Array<ParamType> = [];
const nonIndexed: Array<ParamType> = [];
const dynamic: Array<boolean> = [];
fragment.inputs.forEach((param, index) => {
if (param.indexed) {
if (
param.type === 'string' ||
param.type === 'bytes' ||
param.baseType === 'tuple' ||
param.baseType === 'array'
) {
indexed.push(ParamType.from({ type: 'bytes32', name: param.name }));
dynamic.push(true);
} else {
indexed.push(param);
dynamic.push(false);
}
} else {
nonIndexed.push(param);
dynamic.push(false);
}
});
const resultIndexed = topics != null ? this.#abiCoder.decode(indexed as any, concat(topics)) : null;
const resultNonIndexed = this.#abiCoder.decode(nonIndexed as any, data, true);
//const result: (Array<any> & { [ key: string ]: any }) = [ ];
const values: Array<any> = [];
const keys: Array<null | string> = [];
let nonIndexedIndex = 0,
indexedIndex = 0;
fragment.inputs.forEach((param, index) => {
let value: Indexed | null | unknown = null;
if (param.indexed) {
if (resultIndexed == null) {
value = new Indexed(null);
} else if (dynamic[index]) {
value = new Indexed(resultIndexed[indexedIndex++]);
} else {
try {
value = resultIndexed[indexedIndex++];
} catch (error) {
value = error;
}
}
} else {
try {
value = resultNonIndexed[nonIndexedIndex++];
} catch (error) {
value = error;
}
}
values.push(value);
keys.push(param.name || null);
});
return Result.fromItems(values, keys);
}
/**
* Parses a transaction, finding the matching function and extracts
* the parameter values along with other useful function details.
*
* If the matching function cannot be found, return null.
*/
parseTransaction(tx: { data: string; value?: BigNumberish }): null | TransactionDescription {
const data = getBytes(tx.data, 'tx.data');
const value = getBigInt(tx.value != null ? tx.value : 0, 'tx.value');
const fragment = this.getFunction(hexlify(data.slice(0, 4)));
if (!fragment) {
return null;
}
const args = this.#abiCoder.decode(fragment.inputs as any, data.slice(4));
return new TransactionDescription(fragment, fragment.selector, args, value);
}
parseCallResult(data: BytesLike): Result {
throw new Error('@TODO');
}
/**
* Parses a receipt log, finding the matching event and extracts
* the parameter values along with other useful event details.
*
* If the matching event cannot be found, returns null.
*/
parseLog(log: { topics: Array<string>; data: string }): null | LogDescription {
const fragment = this.getEvent(log.topics[0]);
if (!fragment || fragment.anonymous) {
return null;
}
// @TODO: If anonymous, and the only method, and the input count matches, should we parse?
// Probably not, because just because it is the only event in the ABI does
// not mean we have the full ABI; maybe just a fragment?
return new LogDescription(fragment, fragment.topicHash, this.decodeEventLog(fragment, log.data, log.topics));
}
/**
* Parses a revert data, finding the matching error and extracts
* the parameter values along with other useful error details.
*
* If the matching event cannot be found, returns null.
*/
parseError(data: BytesLike): null | ErrorDescription {
const hexData = hexlify(data);
const fragment = this.getError(dataSlice(hexData, 0, 4));
if (!fragment) {
return null;
}
const args = this.#abiCoder.decode(fragment.inputs as any, dataSlice(hexData, 4));
return new ErrorDescription(fragment, fragment.selector, args);
}
/**
* Creates a new [[Interface]] from the ABI %%value%%.
*
* The %%value%% may be provided as an existing [[Interface]] object,
* a JSON-encoded ABI or any Human-Readable ABI format.
*/
static from(value: InterfaceAbi | Interface): Interface {
// Already an Interface, which is immutable
if (value instanceof Interface) {
return value;
}
// JSON
if (typeof value === 'string') {
return new Interface(JSON.parse(value));
}
// Maybe an interface from an older version, or from a symlinked copy
if (typeof (<any>value).format === 'function') {
return new Interface((<any>value).format('json'));
}
// Array of fragments
return new Interface(value);
}
}
Выполнить команду
Для локальной разработки. Не используйте в интернете!