dequanto 0.0.1 → 0.0.7

package/dist/src/evm/tx.class.js

@@ -0,0 +1,154 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BigNumber = __importStar(require("../../node_modules/big-integer"));
+const functionHashes = __importStar(require("../../data/functionHashes.json"));
+const parseSingle = (data, type) => {
+    if (type === 'string') {
+        return '"' + Buffer.from(data, 'hex').toString('utf8') + '"';
+    }
+    else if (type === 'address') {
+        return '0x' + data.substring(24);
+    }
+    else if (type === 'uint256' || type === 'uint8') {
+        return BigNumber(data, 16).toString();
+    }
+    else if (type === 'bool') {
+        return (!BigNumber(data, 16).isZero()).toString();
+    }
+    else {
+        return data;
+    }
+};
+class Transaction {
+    constructor(transactionObject) {
+        if (transactionObject) {
+            if ('blockHash' in transactionObject) {
+                this.blockHash = transactionObject.blockHash;
+            }
+            if ('blockNumber' in transactionObject) {
+                this.blockNumber = transactionObject.blockNumber;
+            }
+            if ('from' in transactionObject) {
+                this.from = transactionObject.from;
+            }
+            if ('gas' in transactionObject) {
+                this.gas = transactionObject.gas;
+            }
+            if ('gasPrice' in transactionObject) {
+                this.gasPrice = transactionObject.gasPrice;
+            }
+            if ('input' in transactionObject) {
+                this.input = transactionObject.input.replace('0x', '');
+            }
+            if ('to' in transactionObject) {
+                this.to = transactionObject.to;
+            }
+            if ('value' in transactionObject) {
+                this.value = transactionObject.value;
+            }
+        }
+    }
+    setInput(input) {
+        this.input = input.replace('0x', '');
+    }
+    getFunctionHash() {
+        if (this.input && this.input.length >= 8) {
+            return this.input.substr(0, 8);
+        }
+        else {
+            return false;
+        }
+    }
+    getFunction() {
+        const functionHash = this.getFunctionHash();
+        if (functionHash && functionHash in functionHashes) {
+            return functionHashes[functionHash];
+        }
+        else {
+            return false;
+        }
+    }
+    getFunctionName() {
+        const rawFunction = this.getFunction();
+        if (rawFunction) {
+            return rawFunction.split('(')[0];
+        }
+        else {
+            return false;
+        }
+    }
+    getRawArguments() {
+        if (this.input && this.input.length >= 70) {
+            return this.input.substr(8).match(/.{1,64}/g);
+        }
+        else {
+            return [];
+        }
+    }
+    getArguments(descriptive = true) {
+        const functionName = this.getFunction();
+        const functionArguments = this.getRawArguments();
+        if (functionName && this.input) {
+            const rawFunctionArguments = functionName
+                .split('(')[1]
+                .slice(0, -1)
+                .split(',');
+            if (rawFunctionArguments.length === 1 &&
+                rawFunctionArguments[0] === '' &&
+                functionArguments.length === 0) {
+                return [];
+            }
+            else {
+                const result = [];
+                for (let i = 0; i < rawFunctionArguments.length; i++) {
+                    const functionArgumentType = rawFunctionArguments[i] || 'unknown';
+                    const functionArgument = functionArguments[i];
+                    if (functionArgumentType === 'string') {
+                        const location = BigNumber(functionArgument, 16)
+                            .divide(32)
+                            .toJSNumber();
+                        const length = BigNumber(functionArguments[location], 16)
+                            .multiply(2)
+                            .toJSNumber();
+                        const data = this.input.substring(8).substr((location + 1) * 64, length);
+                        result.push(parseSingle(data, functionArgumentType));
+                    }
+                    else {
+                        result.push(parseSingle(functionArgument, functionArgumentType));
+                    }
+                }
+                return result;
+            }
+        }
+        else {
+            return functionArguments;
+        }
+    }
+    isContractCreation() {
+        return this.to === null;
+    }
+}
+exports.default = Transaction;

package/dist/src/evm/utils/BigNumber.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BigNumber = void 0;
+var BigNumber;
+(function (BigNumber) {
+    function isInstance(mix) {
+        return typeof mix === 'bigint';
+    }
+    BigNumber.isInstance = isInstance;
+    function isZero(mix) {
+        return mix === 0n;
+    }
+    BigNumber.isZero = isZero;
+})(BigNumber = exports.BigNumber || (exports.BigNumber = {}));

package/dist/src/evm/utils/hex.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHex = exports.pad32 = exports.hex2a = void 0;
+function hex2a(hexx) {
+    const hex = hexx.toString();
+    let str = '';
+    for (let i = 0; i < hex.length && hex.substr(i, 2) !== '00'; i += 2) {
+        str += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
+    }
+    return str;
+}
+exports.hex2a = hex2a;
+function pad32(data) {
+    if (data.length >= 64) {
+        return data;
+    }
+    else {
+        return '0'.repeat(64 - data.length) + data;
+    }
+}
+exports.pad32 = pad32;
+function isHex(h) {
+    return /^[0-9a-f-]+$/.test(h);
+}
+exports.isHex = isHex;
+exports.default = (data) => {
+    if (isHex(data)) {
+        const pieces = data.match(/.{1,64}/g);
+        if (pieces.length === 3 && parseInt(pieces[0], 16) === 32) {
+            const stringLength = parseInt(pieces[1], 16) * 2;
+            const stringData = hex2a(pieces[2].substr(0, stringLength));
+            return '"' + stringData + '"';
+        }
+        else if (!isNaN(parseInt(data, 16))) {
+            return parseInt(data, 16).toString();
+        }
+        else {
+            return data;
+        }
+    }
+    else {
+        return data;
+    }
+};

package/dist/src/evm/utils/opcodes.js

@@ -0,0 +1,217 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const stop_1 = __importDefault(require("../opcodes/stop"));
+const add_1 = __importDefault(require("../opcodes/add"));
+const mul_1 = __importDefault(require("../opcodes/mul"));
+const sub_1 = __importDefault(require("../opcodes/sub"));
+const div_1 = __importDefault(require("../opcodes/div"));
+const mod_1 = __importDefault(require("../opcodes/mod"));
+const addmod_1 = __importDefault(require("../opcodes/addmod"));
+const mulmod_1 = __importDefault(require("../opcodes/mulmod"));
+const exp_1 = __importDefault(require("../opcodes/exp"));
+const signextend_1 = __importDefault(require("../opcodes/signextend"));
+const lt_1 = __importDefault(require("../opcodes/lt"));
+const gt_1 = __importDefault(require("../opcodes/gt"));
+const eq_1 = __importDefault(require("../opcodes/eq"));
+const iszero_1 = __importDefault(require("../opcodes/iszero"));
+const and_1 = __importDefault(require("../opcodes/and"));
+const or_1 = __importDefault(require("../opcodes/or"));
+const xor_1 = __importDefault(require("../opcodes/xor"));
+const not_1 = __importDefault(require("../opcodes/not"));
+const byte_1 = __importDefault(require("../opcodes/byte"));
+const shl_1 = __importDefault(require("../opcodes/shl"));
+const shr_1 = __importDefault(require("../opcodes/shr"));
+const sar_1 = __importDefault(require("../opcodes/sar"));
+const sha3_1 = __importDefault(require("../opcodes/sha3"));
+const address_1 = __importDefault(require("../opcodes/address"));
+const balance_1 = __importDefault(require("../opcodes/balance"));
+const origin_1 = __importDefault(require("../opcodes/origin"));
+const caller_1 = __importDefault(require("../opcodes/caller"));
+const callvalue_1 = __importDefault(require("../opcodes/callvalue"));
+const calldataload_1 = __importDefault(require("../opcodes/calldataload"));
+const calldatasize_1 = __importDefault(require("../opcodes/calldatasize"));
+const calldatacopy_1 = __importDefault(require("../opcodes/calldatacopy"));
+const codesize_1 = __importDefault(require("../opcodes/codesize"));
+const codecopy_1 = __importDefault(require("../opcodes/codecopy"));
+const gasprice_1 = __importDefault(require("../opcodes/gasprice"));
+const extcodesize_1 = __importDefault(require("../opcodes/extcodesize"));
+const extcodecopy_1 = __importDefault(require("../opcodes/extcodecopy"));
+const returndatasize_1 = __importDefault(require("../opcodes/returndatasize"));
+const returndatacopy_1 = __importDefault(require("../opcodes/returndatacopy"));
+const extcodehash_1 = __importDefault(require("../opcodes/extcodehash"));
+const blockhash_1 = __importDefault(require("../opcodes/blockhash"));
+const coinbase_1 = __importDefault(require("../opcodes/coinbase"));
+const timestamp_1 = __importDefault(require("../opcodes/timestamp"));
+const number_1 = __importDefault(require("../opcodes/number"));
+const difficulty_1 = __importDefault(require("../opcodes/difficulty"));
+const gaslimit_1 = __importDefault(require("../opcodes/gaslimit"));
+const pop_1 = __importDefault(require("../opcodes/pop"));
+const mload_1 = __importDefault(require("../opcodes/mload"));
+const mstore_1 = __importDefault(require("../opcodes/mstore"));
+const sload_1 = __importDefault(require("../opcodes/sload"));
+const sstore_1 = __importDefault(require("../opcodes/sstore"));
+const jump_1 = __importDefault(require("../opcodes/jump"));
+const jumpi_1 = __importDefault(require("../opcodes/jumpi"));
+const pc_1 = __importDefault(require("../opcodes/pc"));
+const msize_1 = __importDefault(require("../opcodes/msize"));
+const gas_1 = __importDefault(require("../opcodes/gas"));
+const jumpdest_1 = __importDefault(require("../opcodes/jumpdest"));
+const push_1 = __importDefault(require("../opcodes/push"));
+const dup_1 = __importDefault(require("../opcodes/dup"));
+const swap_1 = __importDefault(require("../opcodes/swap"));
+const log_1 = __importDefault(require("../opcodes/log"));
+const create_1 = __importDefault(require("../opcodes/create"));
+const call_1 = __importDefault(require("../opcodes/call"));
+const callcode_1 = __importDefault(require("../opcodes/callcode"));
+const return_1 = __importDefault(require("../opcodes/return"));
+const delegatecall_1 = __importDefault(require("../opcodes/delegatecall"));
+const create2_1 = __importDefault(require("../opcodes/create2"));
+const staticcall_1 = __importDefault(require("../opcodes/staticcall"));
+const revert_1 = __importDefault(require("../opcodes/revert"));
+const invalid_1 = __importDefault(require("../opcodes/invalid"));
+const selfdestruct_1 = __importDefault(require("../opcodes/selfdestruct"));
+exports.default = {
+    STOP: stop_1.default,
+    ADD: add_1.default,
+    MUL: mul_1.default,
+    SUB: sub_1.default,
+    DIV: div_1.default,
+    SDIV: div_1.default,
+    MOD: mod_1.default,
+    SMOD: mod_1.default,
+    ADDMOD: addmod_1.default,
+    MULMOD: mulmod_1.default,
+    EXP: exp_1.default,
+    SIGNEXTEND: signextend_1.default,
+    LT: lt_1.default,
+    GT: gt_1.default,
+    SLT: lt_1.default,
+    SGT: gt_1.default,
+    EQ: eq_1.default,
+    ISZERO: iszero_1.default,
+    AND: and_1.default,
+    OR: or_1.default,
+    XOR: xor_1.default,
+    NOT: not_1.default,
+    BYTE: byte_1.default,
+    SHL: shl_1.default,
+    SHR: shr_1.default,
+    SAR: sar_1.default,
+    SHA3: sha3_1.default,
+    ADDRESS: address_1.default,
+    BALANCE: balance_1.default,
+    ORIGIN: origin_1.default,
+    CALLER: caller_1.default,
+    CALLVALUE: callvalue_1.default,
+    CALLDATALOAD: calldataload_1.default,
+    CALLDATASIZE: calldatasize_1.default,
+    CALLDATACOPY: calldatacopy_1.default,
+    CODESIZE: codesize_1.default,
+    CODECOPY: codecopy_1.default,
+    GASPRICE: gasprice_1.default,
+    EXTCODESIZE: extcodesize_1.default,
+    EXTCODECOPY: extcodecopy_1.default,
+    RETURNDATASIZE: returndatasize_1.default,
+    RETURNDATACOPY: returndatacopy_1.default,
+    EXTCODEHASH: extcodehash_1.default,
+    BLOCKHASH: blockhash_1.default,
+    COINBASE: coinbase_1.default,
+    TIMESTAMP: timestamp_1.default,
+    NUMBER: number_1.default,
+    DIFFICULTY: difficulty_1.default,
+    GASLIMIT: gaslimit_1.default,
+    POP: pop_1.default,
+    MLOAD: mload_1.default,
+    MSTORE: mstore_1.default,
+    MSTORE8: mstore_1.default,
+    SLOAD: sload_1.default,
+    SSTORE: sstore_1.default,
+    JUMP: jump_1.default,
+    JUMPI: jumpi_1.default,
+    PC: pc_1.default,
+    MSIZE: msize_1.default,
+    GAS: gas_1.default,
+    JUMPDEST: jumpdest_1.default,
+    PUSH1: push_1.default,
+    PUSH2: push_1.default,
+    PUSH3: push_1.default,
+    PUSH4: push_1.default,
+    PUSH5: push_1.default,
+    PUSH6: push_1.default,
+    PUSH7: push_1.default,
+    PUSH8: push_1.default,
+    PUSH9: push_1.default,
+    PUSH10: push_1.default,
+    PUSH11: push_1.default,
+    PUSH12: push_1.default,
+    PUSH13: push_1.default,
+    PUSH14: push_1.default,
+    PUSH15: push_1.default,
+    PUSH16: push_1.default,
+    PUSH17: push_1.default,
+    PUSH18: push_1.default,
+    PUSH19: push_1.default,
+    PUSH20: push_1.default,
+    PUSH21: push_1.default,
+    PUSH22: push_1.default,
+    PUSH23: push_1.default,
+    PUSH24: push_1.default,
+    PUSH25: push_1.default,
+    PUSH26: push_1.default,
+    PUSH27: push_1.default,
+    PUSH28: push_1.default,
+    PUSH29: push_1.default,
+    PUSH30: push_1.default,
+    PUSH31: push_1.default,
+    PUSH32: push_1.default,
+    DUP1: dup_1.default,
+    DUP2: dup_1.default,
+    DUP3: dup_1.default,
+    DUP4: dup_1.default,
+    DUP5: dup_1.default,
+    DUP6: dup_1.default,
+    DUP7: dup_1.default,
+    DUP8: dup_1.default,
+    DUP9: dup_1.default,
+    DUP10: dup_1.default,
+    DUP11: dup_1.default,
+    DUP12: dup_1.default,
+    DUP13: dup_1.default,
+    DUP14: dup_1.default,
+    DUP15: dup_1.default,
+    DUP16: dup_1.default,
+    SWAP1: swap_1.default,
+    SWAP2: swap_1.default,
+    SWAP3: swap_1.default,
+    SWAP4: swap_1.default,
+    SWAP5: swap_1.default,
+    SWAP6: swap_1.default,
+    SWAP7: swap_1.default,
+    SWAP8: swap_1.default,
+    SWAP9: swap_1.default,
+    SWAP10: swap_1.default,
+    SWAP11: swap_1.default,
+    SWAP12: swap_1.default,
+    SWAP13: swap_1.default,
+    SWAP14: swap_1.default,
+    SWAP15: swap_1.default,
+    SWAP16: swap_1.default,
+    LOG0: log_1.default,
+    LOG1: log_1.default,
+    LOG2: log_1.default,
+    LOG3: log_1.default,
+    LOG4: log_1.default,
+    CREATE: create_1.default,
+    CALL: call_1.default,
+    CALLCODE: callcode_1.default,
+    RETURN: return_1.default,
+    DELEGATECALL: delegatecall_1.default,
+    CREATE2: create2_1.default,
+    STATICCALL: staticcall_1.default,
+    REVERT: revert_1.default,
+    INVALID: invalid_1.default,
+    SELFDESTRUCT: selfdestruct_1.default
+};

package/dist/src/evm/utils/stringify.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _is_1 = require("@dequanto/utils/$is");
+exports.default = (item) => {
+    if (_is_1.$is.BigInt(item)) {
+        return item.toString(16);
+    }
+    else if (!item.wrapped) {
+        return item.toString();
+    }
+    else {
+        return '(' + item.toString() + ')';
+    }
+};

package/dist/src/evm/utils/stringifyEvents.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (stateEvents, events) => {
+    const stateEventValues = Object.keys(stateEvents).map((key) => stateEvents[key]);
+    let output = '';
+    events.forEach((event) => {
+        const eventName = event.split('(')[0];
+        const eventArguments = event
+            .replace(eventName, '')
+            .substring(1)
+            .slice(0, -1);
+        output += 'event ';
+        if (eventArguments) {
+            output += eventName + '(';
+            output += eventArguments
+                .split(',')
+                .map((a, i) => {
+                const stateEvent = stateEventValues.find((e) => e.label === event);
+                if (stateEvent && i < stateEvent.indexedCount) {
+                    return a + ' indexed _arg' + i;
+                }
+                else {
+                    return a + ' _arg' + i;
+                }
+            })
+                .join(', ');
+            output += ')';
+        }
+        else {
+            output += event;
+        }
+        output += '\n';
+    });
+    if (events.length > 0) {
+        output += '\n';
+    }
+    return output;
+};

package/dist/src/evm/utils/stringifyFunctions.js

@@ -0,0 +1,70 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const stringifyInstructions_1 = __importDefault(require("./stringifyInstructions"));
+const functionHashes = __importStar(require("../../data/functionHashes.json"));
+exports.default = (functionName, functionInstance) => {
+    let output = '';
+    output += 'function ';
+    if (functionName in functionHashes) {
+        const fullFunction = functionHashes[functionName];
+        const fullFunctionName = fullFunction.split('(')[0];
+        const fullFunctionArguments = fullFunction
+            .replace(fullFunctionName, '')
+            .substring(1)
+            .slice(0, -1);
+        if (fullFunctionArguments) {
+            output += fullFunctionName + '(';
+            output += fullFunctionArguments
+                .split(',')
+                .map((a, i) => a + ' _arg' + i)
+                .join(', ');
+            output += ')';
+        }
+        else {
+            output += fullFunction;
+        }
+    }
+    else {
+        output += functionName + '()';
+    }
+    output += ' ' + functionInstance.visibility;
+    if (functionInstance.constant) {
+        output += ' view';
+    }
+    if (functionInstance.payable) {
+        output += ' payable';
+    }
+    if (functionInstance.returns.length > 0) {
+        output += ' returns (' + functionInstance.returns.join(', ') + ')';
+    }
+    output += ' {\n';
+    output += (0, stringifyInstructions_1.default)(functionInstance.items, 4);
+    output += '}\n\n';
+    return output;
+};

package/dist/src/evm/utils/stringifyInstructions.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyInstructions = void 0;
+const stringifyInstructions = (instructionTree, indentation = 0) => {
+    let instructionLines = '';
+    instructionTree.forEach((instruction) => {
+        if (instruction.name === 'JUMPI' && instruction.false) {
+            const condition = instruction.toString();
+            const falseInstructions = instruction.false.filter((i) => i.debugLevel > 0);
+            if (falseInstructions.length === 1 && falseInstructions[0].name === 'JUMPI') {
+                instructionLines += ' '.repeat(indentation) + 'if' + condition + ' {\n';
+                instructionLines += (0, exports.stringifyInstructions)(instruction.true, indentation + 4);
+                instructionLines += ' '.repeat(indentation) + '} else ';
+                const elseOrElseIf = (0, exports.stringifyInstructions)(instruction.false, indentation);
+                if (elseOrElseIf.trim().startsWith('if')) {
+                    instructionLines += elseOrElseIf.trim() + '\n';
+                }
+                else {
+                    instructionLines +=
+                        '{\n' +
+                            elseOrElseIf
+                                .split('\n')
+                                .filter(l => l)
+                                .map(l => ' '.repeat(4) + l)
+                                .join('\n');
+                    instructionLines += '\n' + ' '.repeat(indentation) + '}\n';
+                }
+            }
+            else {
+                instructionLines += ' '.repeat(indentation) + 'if' + condition + ' {\n';
+                instructionLines += (0, exports.stringifyInstructions)(instruction.true, indentation + 4);
+                instructionLines += ' '.repeat(indentation) + '} else {\n';
+                instructionLines += (0, exports.stringifyInstructions)(instruction.false, indentation + 4);
+                instructionLines += ' '.repeat(indentation) + '}\n';
+            }
+        }
+        else {
+            instructionLines += ' '.repeat(indentation) + instruction.toString() + '\n';
+        }
+    });
+    return instructionLines;
+};
+exports.stringifyInstructions = stringifyInstructions;
+exports.default = exports.stringifyInstructions;

package/dist/src/evm/utils/stringifyMappings.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stringifyMapping = (mapping) => {
+    const mappingKey = [];
+    const mappingValue = [];
+    let deepMapping = false;
+    mapping.keys
+        .filter((mappingChild) => mappingChild.length > 0)
+        .forEach((mappingChild) => {
+        if (mappingChild.length > 0 &&
+            mappingChild[0].type &&
+            !mappingKey.includes(mappingChild[0].type)) {
+            mappingKey.push(mappingChild[0].type);
+        }
+        if (mappingChild.length > 1 && !deepMapping) {
+            deepMapping = true;
+            mappingValue.push(stringifyMapping({
+                name: mapping.name,
+                structs: mapping.structs,
+                keys: mapping.keys.map((items) => {
+                    items.shift();
+                    return items;
+                }),
+                values: mapping.values
+            }));
+        }
+        else if (mappingChild.length === 1 && !deepMapping) {
+            mapping.values.forEach((mappingChild2) => {
+                if (mappingChild2.type && !mappingValue.includes(mappingChild2.type)) {
+                    mappingValue.push(mappingChild2.type);
+                }
+            });
+        }
+    });
+    if (mappingKey.length === 0) {
+        mappingKey.push('unknown');
+    }
+    if (mapping.structs.length > 0 && mappingValue.length === 0) {
+        mappingValue.push(mapping.name + 'Struct');
+    }
+    else if (mappingValue.length === 0) {
+        mappingValue.push('unknown');
+    }
+    return 'mapping (' + mappingKey.join('|') + ' => ' + mappingValue.join('|') + ')';
+};
+exports.default = (mappings) => {
+    let output = '';
+    Object.keys(mappings).forEach((key, index) => {
+        const mapping = mappings[key];
+        if (mapping.name) {
+            output += stringifyMapping(mapping) + ' public ' + mapping.name + ';';
+        }
+        else {
+            output += stringifyMapping(mapping) + ' mapping' + (index + 1) + ';';
+        }
+        output += '\n';
+    });
+    if (Object.keys(mappings).length > 0) {
+        output += '\n';
+    }
+    return output;
+};

package/dist/src/evm/utils/stringifyStructs.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (mappings) => {
+    let output = '';
+    Object.keys(mappings)
+        .filter((key) => mappings[key].structs.length > 0)
+        .forEach((key, index) => {
+        const mapping = mappings[key];
+        output += 'struct ' + mapping.name + 'Struct {\n';
+        mapping.structs.forEach((struct) => {
+            output += '    ' + struct.toString() + ';\n';
+        });
+        output += '}\n\n';
+    });
+    return output;
+};