diff --git a/src/debug/artifact_manager/artifact_manager.ts b/src/debug/artifact_manager/artifact_manager.ts new file mode 100644 index 0000000..71cc03b --- /dev/null +++ b/src/debug/artifact_manager/artifact_manager.ts @@ -0,0 +1,415 @@ +import { PrefixedHexString } from "@ethereumjs/util"; +import { bytesToHex, hexToBytes } from "ethereum-cryptography/utils"; +import { + ASTContext, + ASTNode, + ASTReader, + ContractDefinition, + FunctionDefinition, + FunctionVisibility, + InferType, + SourceUnit, + StateVariableVisibility, + VariableDeclaration, + assert, + getABIEncoderVersion +} from "solc-typed-ast"; +import { ABIEncoderVersion } from "solc-typed-ast/dist/types/abi"; +import { + DecodedBytecodeSourceMapEntry, + PartialBytecodeDescription, + PartialCompiledContract, + PartialSolcOutput, + RawAST, + UnprefixedHexString, + fastParseBytecodeSourceMapping, + findContractDef, + getArtifactCompilerVersion, + getCodeHash, + getCreationCodeHash +} from "../.."; +import { HexString } from "../../artifacts"; +import { OpcodeInfo } from "../opcodes"; +import { BytecodeTemplate, makeTemplate, matchesTemplate } from "./bytecode_templates"; + +export interface IArtifactManager { + getContractFromDeployedBytecode(code: Uint8Array): ContractInfo | undefined; + getContractFromCreationBytecode(code: Uint8Array): ContractInfo | undefined; + getContractFromMDHash(hash: HexString): ContractInfo | undefined; + artifacts(): ArtifactInfo[]; + contracts(): ContractInfo[]; + // TODO: Need a better way of identifying runtime contracts than (bytecode, isCreation) + getFileById(id: number, code: Uint8Array, isCreation: boolean): SourceFileInfo | undefined; + infer(version: string): InferType; + findMethod( + selector: HexString | Uint8Array + ): [ContractInfo, FunctionDefinition | VariableDeclaration] | undefined; +} + +export interface BytecodeInfo { + // Map from the file-id (used in source maps in this artifact) to the generated Yul sources for this contract's creation bytecode. + // Note that multiple contracts have overlapping generated units ids, so we need a mapping per-contract + generatedFileMap: Map; + srcMap: DecodedBytecodeSourceMapEntry[]; + offsetToIndexMap: Map; +} + +export interface ContractInfo { + artifact: ArtifactInfo; + contractArtifact: PartialCompiledContract; + contractName: string; + fileName: string; + ast: ContractDefinition | undefined; + bytecode: BytecodeInfo; + deployedBytecode: BytecodeInfo; + mdHash: PrefixedHexString; +} + +export interface ArtifactInfo { + artifact: PartialSolcOutput; + units: SourceUnit[]; + ctx: ASTContext; + compilerVersion: string; + abiEncoderVersion: ABIEncoderVersion; + // Map from the file-id (used in source maps in this artifact) to the actual sources entry (and some additional info) + fileMap: Map; + // Map from src triples to AST nodes with that source range + srcMap: Map; +} + +export enum SourceFileType { + Solidity = "solidity", + InternalYul = "internal_yul" +} + +export interface SourceFileInfo { + contents: string | undefined; + rawAst: RawAST; + ast: SourceUnit | undefined; + name: string; + fileIndex: number; + type: SourceFileType; +} + +/** + * Build an offset-to-instruction index map for the given bytecode. Note + * that since its not easy to tell exactly where the instruction section ends, we + * over-approximate by also mapping any potential data sections at the end of bytecode. + * + * The main assumption we make is that all non-instruction bytecode comes at the end of the + * bytecode. + */ +function buildOffsetToIndexMap(bytecode: Uint8Array | UnprefixedHexString): Map { + if (typeof bytecode === "string") { + bytecode = hexToBytes(bytecode); + } + + const res = new Map(); + + for (let i = 0, off = 0; off < bytecode.length; i++) { + const op = OpcodeInfo[bytecode[off]]; + + res.set(off, i); + + off += op.length; + } + + return res; +} + +export function getOffsetSrc(off: number, bytecode: BytecodeInfo): DecodedBytecodeSourceMapEntry { + const idx = bytecode.offsetToIndexMap.get(off); + + assert(idx !== undefined, `No index for code offset ${off}`); + assert( + idx >= 0 && idx < bytecode.srcMap.length, + `Instruction index ${idx} outside of source map (0-${bytecode.srcMap.length})` + ); + + return bytecode.srcMap[idx]; +} + +/** + * ArtifactManager contains a set of solc standard JSON compiler artifacts, and allows for quick + * lookup from creation or deployed bytecode to the actual compiler artifact. + */ +export class ArtifactManager implements IArtifactManager { + private _artifacts: ArtifactInfo[]; + private _contracts: ContractInfo[]; + private _mdHashToContractInfo: Map; + private _inferCache = new Map(); + private _creationBytecodeTemplates: BytecodeTemplate[]; + private _deployedBytecodeTemplates: BytecodeTemplate[]; + + /** + * Helper to pick a canonical ABI encode version for a set of units. + * For now just pick the highest version among the files + * @todo (dimo) I am not sure this function is correct. Seems to work for now + */ + private pickABIEncoderVersion(units: SourceUnit[], compilerVersion: string): ABIEncoderVersion { + const versions = new Set( + units.map((unit) => getABIEncoderVersion(unit, compilerVersion)) + ); + + if (versions.has(ABIEncoderVersion.V2)) { + return ABIEncoderVersion.V2; + } + + return ABIEncoderVersion.V1; + } + + constructor(artifacts: PartialSolcOutput[]) { + this._artifacts = []; + this._contracts = []; + this._mdHashToContractInfo = new Map(); + this._creationBytecodeTemplates = []; + this._deployedBytecodeTemplates = []; + + for (const artifact of artifacts) { + const reader = new ASTReader(); + const compilerVersion = getArtifactCompilerVersion(artifact); + + assert(compilerVersion !== undefined, `Couldn't find compiler version for artifact`); + + const units = reader.read(artifact); + const abiEncoderVersion = this.pickABIEncoderVersion(units, compilerVersion); + const fileMap = new Map(); + const unitMap = new Map(units.map((unit) => [unit.id, unit])); + + for (const fileName in artifact.sources) { + const sourceInfo = artifact.sources[fileName]; + // TODO: This is hacky. Figure out a cleaner aay to get the fileIndex + const fileIdx = + sourceInfo.fileIndex !== undefined ? sourceInfo.fileIndex : sourceInfo.id; + + fileMap.set(fileIdx, { + contents: sourceInfo.contents, + rawAst: sourceInfo.ast, + ast: unitMap.get(sourceInfo.ast.id), + name: fileName, + fileIndex: fileIdx, + type: SourceFileType.Solidity + }); + } + + const srcMap = new Map(); + + for (const unit of units) { + unit.walkChildren((child) => srcMap.set(child.src, child)); + } + + this._artifacts.push({ + artifact, + units, + ctx: reader.context, + compilerVersion, + abiEncoderVersion, + fileMap, + srcMap + }); + } + + for (const artifactInfo of this._artifacts) { + const artifact = artifactInfo.artifact; + + for (const fileName in artifact.contracts) { + for (const contractName in artifact.contracts[fileName]) { + const contractDef = findContractDef(artifactInfo.units, fileName, contractName); + const contractArtifact = artifact.contracts[fileName][contractName]; + const generatedFileMap = new Map(); + const deployedGeneratedFileMap = new Map(); + + for (const [srcMap, bytecodeInfo] of [ + [generatedFileMap, contractArtifact.evm.bytecode], + [deployedGeneratedFileMap, contractArtifact.evm.deployedBytecode] + ] as Array<[Map, PartialBytecodeDescription]>) { + if (!bytecodeInfo.generatedSources) { + continue; + } + + for (const src of bytecodeInfo.generatedSources) { + srcMap.set(src.id, { + rawAst: src.ast, + ast: undefined, + name: src.name ? src.name : "", + contents: src.contents ? src.contents : undefined, + type: SourceFileType.InternalYul, + fileIndex: src.id + }); + } + } + + const hash = getCodeHash(contractArtifact.evm.deployedBytecode.object); + + assert( + hash !== undefined, + `Couldn't find md in bytecode for ${contractName} from ${fileName}` + ); + + const contractInfo: ContractInfo = { + artifact: artifactInfo, + contractArtifact: contractArtifact, + fileName, + contractName, + ast: contractDef, + bytecode: { + generatedFileMap, + srcMap: fastParseBytecodeSourceMapping( + contractArtifact.evm.bytecode.sourceMap + ), + offsetToIndexMap: buildOffsetToIndexMap( + contractArtifact.evm.bytecode.object + ) + }, + deployedBytecode: { + generatedFileMap: deployedGeneratedFileMap, + srcMap: fastParseBytecodeSourceMapping( + contractArtifact.evm.deployedBytecode.sourceMap + ), + offsetToIndexMap: buildOffsetToIndexMap( + contractArtifact.evm.deployedBytecode.object + ) + }, + mdHash: hash + }; + + this._contracts.push(contractInfo); + + this._mdHashToContractInfo.set(hash, contractInfo); + + this._creationBytecodeTemplates.push( + makeTemplate(contractArtifact.evm.bytecode) + ); + + this._deployedBytecodeTemplates.push( + makeTemplate(contractArtifact.evm.deployedBytecode) + ); + } + } + } + } + + artifacts(): ArtifactInfo[] { + return this._artifacts; + } + + getContractFromMDHash(hash: HexString): ContractInfo | undefined { + return this._mdHashToContractInfo.get(hash); + } + + getContractFromDeployedBytecode(bytecode: Uint8Array): ContractInfo | undefined { + const hash = getCodeHash(bytecode); + + if (hash) { + return this._mdHashToContractInfo.get(hash); + } + + for (let i = 0; i < this._deployedBytecodeTemplates.length; i++) { + const templ = this._deployedBytecodeTemplates[i]; + + if (matchesTemplate(bytecode, templ)) { + return this._contracts[i]; + } + } + + return undefined; + } + + getContractFromCreationBytecode(creationBytecode: Uint8Array): ContractInfo | undefined { + const hash = getCreationCodeHash(creationBytecode); + + if (hash) { + return this._mdHashToContractInfo.get(hash); + } + + for (let i = 0; i < this._creationBytecodeTemplates.length; i++) { + const templ = this._creationBytecodeTemplates[i]; + + if (matchesTemplate(creationBytecode, templ)) { + return this._contracts[i]; + } + } + + return undefined; + } + + getFileById( + id: number, + arg: Uint8Array | ContractInfo, + isCreation: boolean + ): SourceFileInfo | undefined { + let contractInfo: ContractInfo | undefined; + + if (typeof arg === "string" || arg instanceof Uint8Array) { + contractInfo = isCreation + ? this.getContractFromCreationBytecode(arg) + : this.getContractFromDeployedBytecode(arg); + } else { + contractInfo = arg; + } + + if (contractInfo === undefined) { + return undefined; + } + + const genFilesMap = isCreation + ? contractInfo.bytecode.generatedFileMap + : contractInfo.deployedBytecode.generatedFileMap; + + const res = genFilesMap.get(id); + + if (res) { + return res; + } + + return contractInfo.artifact.fileMap.get(id); + } + + contracts(): ContractInfo[] { + return this._contracts; + } + + infer(version: string): InferType { + if (!this._inferCache.has(version)) { + this._inferCache.set(version, new InferType(version)); + } + + return this._inferCache.get(version) as InferType; + } + + findMethod( + selector: HexString | Uint8Array + ): [ContractInfo, FunctionDefinition | VariableDeclaration] | undefined { + if (selector instanceof Uint8Array) { + selector = bytesToHex(selector); + } + + for (const contract of this._contracts) { + if (!contract.ast) { + continue; + } + + const inf = this.infer(contract.artifact.compilerVersion); + const ast = contract.ast; + + const candidates = [ + ...ast.vFunctions.filter( + (method) => + method.visibility === FunctionVisibility.External || + method.visibility === FunctionVisibility.Public + ), + ...ast.vStateVariables.filter( + (getter) => getter.visibility === StateVariableVisibility.Public + ) + ]; + + for (const node of candidates) { + if (inf.signatureHash(node) === selector) { + return [contract, node]; + } + } + } + + return undefined; + } +} diff --git a/src/debug/artifact_manager/bytecode_templates.ts b/src/debug/artifact_manager/bytecode_templates.ts new file mode 100644 index 0000000..ffc3dcc --- /dev/null +++ b/src/debug/artifact_manager/bytecode_templates.ts @@ -0,0 +1,65 @@ +import { equalsBytes, hexToBytes } from "@ethereumjs/util"; +import { PartialBytecodeDescription, RangeList } from "../../artifacts"; + +export interface BytecodeTemplate { + object: Uint8Array; + skipRanges: Array<[number, number]>; +} + +function makeSkipRanges(rawList: RangeList): Array<[number, number]> { + return rawList.map((raw) => [raw.start, raw.start + raw.length]); +} + +export function makeTemplate(artifact: PartialBytecodeDescription): BytecodeTemplate { + const skipRanges: Array<[number, number]> = []; + + if (artifact.linkReferences) { + for (const obj of Object.values(artifact.linkReferences)) { + for (const ranges of Object.values(obj)) { + skipRanges.push(...makeSkipRanges(ranges)); + } + } + } + + if (artifact.immutableReferences) { + for (const ranges of Object.values(artifact.immutableReferences)) { + skipRanges.push(...makeSkipRanges(ranges)); + } + } + + skipRanges.sort(); + + return { + object: hexToBytes("0x" + artifact.object), + skipRanges + }; +} + +export function matchesTemplate(bytecode: Uint8Array, template: BytecodeTemplate): boolean { + if (bytecode.length !== template.object.length) { + return false; + } + + let curIdx = 0; + let rangeIdx = 0; + + while (curIdx < template.object.length) { + let nextIdx: number; + let compEnd: number; + + if (rangeIdx < template.skipRanges.length) { + [compEnd, nextIdx] = template.skipRanges[rangeIdx]; + } else { + compEnd = nextIdx = template.object.length; + } + + if (!equalsBytes(bytecode.slice(curIdx, compEnd), template.object.slice(curIdx, compEnd))) { + return false; + } + + curIdx = nextIdx; + rangeIdx++; + } + + return true; +} diff --git a/src/debug/artifact_manager/index.ts b/src/debug/artifact_manager/index.ts new file mode 100644 index 0000000..d79c908 --- /dev/null +++ b/src/debug/artifact_manager/index.ts @@ -0,0 +1 @@ +export * from "./artifact_manager"; diff --git a/test/samples/local/contract_lifetime/artifacts/main.json b/test/samples/local/contract_lifetime/artifacts/main.json new file mode 100644 index 0000000..dd9237e --- /dev/null +++ b/test/samples/local/contract_lifetime/artifacts/main.json @@ -0,0 +1,4748 @@ +{ + "contracts": { + "contracts/contract_lifetime.sol": { + "FailingConstructor": { + "abi": [ + { + "inputs": [], + "stateMutability": "nonpayable", + "type": "constructor" + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "evm": { + "assembly": " /* \"contracts/contract_lifetime.sol\":25:107 contract FailingConstructor {... */\n mstore(0x40, 0x80)\n /* \"contracts/contract_lifetime.sol\":59:105 constructor() public {... */\n callvalue\n dup1\n iszero\n tag_1\n jumpi\n 0x00\n dup1\n revert\ntag_1:\n /* \"contracts/contract_lifetime.sol\":90:98 revert() */\n 0x00\n dup1\n revert\nstop\n\nsub_0: assembly {\n /* \"contracts/contract_lifetime.sol\":25:107 contract FailingConstructor {... */\n mstore(0x40, 0x80)\n 0x00\n dup1\n revert\n\n auxdata: 0xa2646970667358221220e069b7a08f49be425c056ed0e7009fc31d74ca63d855a9abd28d07edcf2f9cd864736f6c63430008150033\n}\n", + "bytecode": { + "functionDebugData": { + "@_8": { + "entryPoint": null, + "id": 8, + "parameterSlots": 0, + "returnSlots": 0 + } + }, + "generatedSources": [], + "linkReferences": {}, + "object": "6080604052348015600e575f80fd5b5f80fdfe", + "opcodes": "PUSH1 0x80 PUSH1 0x40 MSTORE CALLVALUE DUP1 ISZERO PUSH1 0xE JUMPI PUSH0 DUP1 REVERT JUMPDEST PUSH0 DUP1 REVERT INVALID ", + "sourceMap": "25:82:0:-:0;;;59:46;;;;;;;;;90:8;;" + }, + "deployedBytecode": { + "functionDebugData": {}, + "generatedSources": [], + "immutableReferences": {}, + "linkReferences": {}, + "object": "60806040525f80fdfea2646970667358221220e069b7a08f49be425c056ed0e7009fc31d74ca63d855a9abd28d07edcf2f9cd864736f6c63430008150033", + "opcodes": "PUSH1 0x80 PUSH1 0x40 MSTORE PUSH0 DUP1 REVERT INVALID LOG2 PUSH5 0x6970667358 0x22 SLT KECCAK256 0xE0 PUSH10 0xB7A08F49BE425C056ED0 0xE7 STOP SWAP16 0xC3 SAR PUSH21 0xCA63D855A9ABD28D07EDCF2F9CD864736F6C634300 ADDMOD ISZERO STOP CALLER ", + "sourceMap": "25:82:0:-:0;;;;;" + }, + "gasEstimates": { + "creation": { + "codeDepositCost": "12400", + "executionCost": "45", + "totalCost": "12445" + } + }, + "legacyAssembly": { + ".code": [ + { + "begin": 25, + "end": 107, + "name": "PUSH", + "source": 0, + "value": "80" + }, + { + "begin": 25, + "end": 107, + "name": "PUSH", + "source": 0, + "value": "40" + }, + { + "begin": 25, + "end": 107, + "name": "MSTORE", + "source": 0 + }, + { + "begin": 59, + "end": 105, + "name": "CALLVALUE", + "source": 0 + }, + { + "begin": 59, + "end": 105, + "name": "DUP1", + "source": 0 + }, + { + "begin": 59, + "end": 105, + "name": "ISZERO", + "source": 0 + }, + { + "begin": 59, + "end": 105, + "name": "PUSH [tag]", + "source": 0, + "value": "1" + }, + { + "begin": 59, + "end": 105, + "name": "JUMPI", + "source": 0 + }, + { + "begin": 59, + "end": 105, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 59, + "end": 105, + "name": "DUP1", + "source": 0 + }, + { + "begin": 59, + "end": 105, + "name": "REVERT", + "source": 0 + }, + { + "begin": 59, + "end": 105, + "name": "tag", + "source": 0, + "value": "1" + }, + { + "begin": 59, + "end": 105, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 90, + "end": 98, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 90, + "end": 98, + "name": "DUP1", + "source": 0 + }, + { + "begin": 90, + "end": 98, + "name": "REVERT", + "source": 0 + } + ], + ".data": { + "0": { + ".auxdata": "a2646970667358221220e069b7a08f49be425c056ed0e7009fc31d74ca63d855a9abd28d07edcf2f9cd864736f6c63430008150033", + ".code": [ + { + "begin": 25, + "end": 107, + "name": "PUSH", + "source": 0, + "value": "80" + }, + { + "begin": 25, + "end": 107, + "name": "PUSH", + "source": 0, + "value": "40" + }, + { + "begin": 25, + "end": 107, + "name": "MSTORE", + "source": 0 + }, + { + "begin": 25, + "end": 107, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 25, + "end": 107, + "name": "DUP1", + "source": 0 + }, + { + "begin": 25, + "end": 107, + "name": "REVERT", + "source": 0 + } + ] + } + }, + "sourceList": [ + "contracts/contract_lifetime.sol", + "#utility.yul" + ] + }, + "methodIdentifiers": {} + }, + "metadata": "{\"compiler\":{\"version\":\"0.8.21+commit.d9974bed\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/contract_lifetime.sol\":\"FailingConstructor\"},\"evmVersion\":\"shanghai\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":false,\"runs\":200},\"remappings\":[]},\"sources\":{\"contracts/contract_lifetime.sol\":{\"keccak256\":\"0xdf64ae2ed4e5ccfc5181d0a5130424ef00fde2fee461c208bbc25fb02ffd6a59\",\"urls\":[\"bzz-raw://31be55bd8433f2afa420146694e3a1f68bd1eb3d8171fdcc00e6ec0c0c8bdb19\",\"dweb:/ipfs/QmUtuKNtyRRqRxzbLa2FyaDjtjLwnC1vfaPaTLs3rxKCym\"]}},\"version\":1}", + "storageLayout": { + "storage": [], + "types": null + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + } + }, + "Killable": { + "abi": [ + { + "inputs": [], + "name": "die", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "evm": { + "assembly": " /* \"contracts/contract_lifetime.sol\":109:200 contract Killable {... */\n mstore(0x40, 0x80)\n callvalue\n dup1\n iszero\n tag_1\n jumpi\n 0x00\n dup1\n revert\ntag_1:\n pop\n dataSize(sub_0)\n dup1\n dataOffset(sub_0)\n 0x00\n codecopy\n 0x00\n return\nstop\n\nsub_0: assembly {\n /* \"contracts/contract_lifetime.sol\":109:200 contract Killable {... */\n mstore(0x40, 0x80)\n callvalue\n dup1\n iszero\n tag_1\n jumpi\n 0x00\n dup1\n revert\n tag_1:\n pop\n jumpi(tag_2, lt(calldatasize, 0x04))\n shr(0xe0, calldataload(0x00))\n dup1\n 0x35f46994\n eq\n tag_3\n jumpi\n tag_2:\n 0x00\n dup1\n revert\n /* \"contracts/contract_lifetime.sol\":133:198 function die() public {... */\n tag_3:\n tag_4\n tag_5\n jump\t// in\n tag_4:\n stop\n tag_5:\n /* \"contracts/contract_lifetime.sol\":186:189 0x0 */\n 0x00\n /* \"contracts/contract_lifetime.sol\":165:191 selfdestruct(payable(0x0)) */\n 0xffffffffffffffffffffffffffffffffffffffff\n and\n selfdestruct\n\n auxdata: 0xa2646970667358221220aac49067c690fc4a7a711ec18c9a8b6accf3004cea6deef0a7f51a029997a97e64736f6c63430008150033\n}\n", + "bytecode": { + "functionDebugData": {}, + "generatedSources": [], + "linkReferences": {}, + "object": "6080604052348015600e575f80fd5b5060818061001b5f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c806335f4699414602a575b5f80fd5b60306032565b005b5f73ffffffffffffffffffffffffffffffffffffffff16fffea2646970667358221220aac49067c690fc4a7a711ec18c9a8b6accf3004cea6deef0a7f51a029997a97e64736f6c63430008150033", + "opcodes": "PUSH1 0x80 PUSH1 0x40 MSTORE CALLVALUE DUP1 ISZERO PUSH1 0xE JUMPI PUSH0 DUP1 REVERT JUMPDEST POP PUSH1 0x81 DUP1 PUSH2 0x1B PUSH0 CODECOPY PUSH0 RETURN INVALID PUSH1 0x80 PUSH1 0x40 MSTORE CALLVALUE DUP1 ISZERO PUSH1 0xE JUMPI PUSH0 DUP1 REVERT JUMPDEST POP PUSH1 0x4 CALLDATASIZE LT PUSH1 0x26 JUMPI PUSH0 CALLDATALOAD PUSH1 0xE0 SHR DUP1 PUSH4 0x35F46994 EQ PUSH1 0x2A JUMPI JUMPDEST PUSH0 DUP1 REVERT JUMPDEST PUSH1 0x30 PUSH1 0x32 JUMP JUMPDEST STOP JUMPDEST PUSH0 PUSH20 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF AND SELFDESTRUCT INVALID LOG2 PUSH5 0x6970667358 0x22 SLT KECCAK256 0xAA 0xC4 SWAP1 PUSH8 0xC690FC4A7A711EC1 DUP13 SWAP11 DUP12 PUSH11 0xCCF3004CEA6DEEF0A7F51A MUL SWAP10 SWAP8 0xA9 PUSH31 0x64736F6C634300081500330000000000000000000000000000000000000000 ", + "sourceMap": "109:91:0:-:0;;;;;;;;;;;;;;;;;;;" + }, + "deployedBytecode": { + "functionDebugData": { + "@die_20": { + "entryPoint": 50, + "id": 20, + "parameterSlots": 0, + "returnSlots": 0 + } + }, + "generatedSources": [], + "immutableReferences": {}, + "linkReferences": {}, + "object": "6080604052348015600e575f80fd5b50600436106026575f3560e01c806335f4699414602a575b5f80fd5b60306032565b005b5f73ffffffffffffffffffffffffffffffffffffffff16fffea2646970667358221220aac49067c690fc4a7a711ec18c9a8b6accf3004cea6deef0a7f51a029997a97e64736f6c63430008150033", + "opcodes": "PUSH1 0x80 PUSH1 0x40 MSTORE CALLVALUE DUP1 ISZERO PUSH1 0xE JUMPI PUSH0 DUP1 REVERT JUMPDEST POP PUSH1 0x4 CALLDATASIZE LT PUSH1 0x26 JUMPI PUSH0 CALLDATALOAD PUSH1 0xE0 SHR DUP1 PUSH4 0x35F46994 EQ PUSH1 0x2A JUMPI JUMPDEST PUSH0 DUP1 REVERT JUMPDEST PUSH1 0x30 PUSH1 0x32 JUMP JUMPDEST STOP JUMPDEST PUSH0 PUSH20 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF AND SELFDESTRUCT INVALID LOG2 PUSH5 0x6970667358 0x22 SLT KECCAK256 0xAA 0xC4 SWAP1 PUSH8 0xC690FC4A7A711EC1 DUP13 SWAP11 DUP12 PUSH11 0xCCF3004CEA6DEEF0A7F51A MUL SWAP10 SWAP8 0xA9 PUSH31 0x64736F6C634300081500330000000000000000000000000000000000000000 ", + "sourceMap": "109:91:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;133:65;;;:::i;:::-;;;186:3;165:26;;" + }, + "gasEstimates": { + "creation": { + "codeDepositCost": "25800", + "executionCost": "79", + "totalCost": "25879" + }, + "external": { + "die()": "27720" + } + }, + "legacyAssembly": { + ".code": [ + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "80" + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "40" + }, + { + "begin": 109, + "end": 200, + "name": "MSTORE", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "CALLVALUE", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "DUP1", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "ISZERO", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH [tag]", + "source": 0, + "value": "1" + }, + { + "begin": 109, + "end": 200, + "name": "JUMPI", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 109, + "end": 200, + "name": "DUP1", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "REVERT", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "tag", + "source": 0, + "value": "1" + }, + { + "begin": 109, + "end": 200, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "POP", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH #[$]", + "source": 0, + "value": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "begin": 109, + "end": 200, + "name": "DUP1", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH [$]", + "source": 0, + "value": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 109, + "end": 200, + "name": "CODECOPY", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 109, + "end": 200, + "name": "RETURN", + "source": 0 + } + ], + ".data": { + "0": { + ".auxdata": "a2646970667358221220aac49067c690fc4a7a711ec18c9a8b6accf3004cea6deef0a7f51a029997a97e64736f6c63430008150033", + ".code": [ + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "80" + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "40" + }, + { + "begin": 109, + "end": 200, + "name": "MSTORE", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "CALLVALUE", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "DUP1", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "ISZERO", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH [tag]", + "source": 0, + "value": "1" + }, + { + "begin": 109, + "end": 200, + "name": "JUMPI", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 109, + "end": 200, + "name": "DUP1", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "REVERT", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "tag", + "source": 0, + "value": "1" + }, + { + "begin": 109, + "end": 200, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "POP", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "4" + }, + { + "begin": 109, + "end": 200, + "name": "CALLDATASIZE", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "LT", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH [tag]", + "source": 0, + "value": "2" + }, + { + "begin": 109, + "end": 200, + "name": "JUMPI", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 109, + "end": 200, + "name": "CALLDATALOAD", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "E0" + }, + { + "begin": 109, + "end": 200, + "name": "SHR", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "DUP1", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "35F46994" + }, + { + "begin": 109, + "end": 200, + "name": "EQ", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH [tag]", + "source": 0, + "value": "3" + }, + { + "begin": 109, + "end": 200, + "name": "JUMPI", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "tag", + "source": 0, + "value": "2" + }, + { + "begin": 109, + "end": 200, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 109, + "end": 200, + "name": "DUP1", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "REVERT", + "source": 0 + }, + { + "begin": 133, + "end": 198, + "name": "tag", + "source": 0, + "value": "3" + }, + { + "begin": 133, + "end": 198, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 133, + "end": 198, + "name": "PUSH [tag]", + "source": 0, + "value": "4" + }, + { + "begin": 133, + "end": 198, + "name": "PUSH [tag]", + "source": 0, + "value": "5" + }, + { + "begin": 133, + "end": 198, + "jumpType": "[in]", + "name": "JUMP", + "source": 0 + }, + { + "begin": 133, + "end": 198, + "name": "tag", + "source": 0, + "value": "4" + }, + { + "begin": 133, + "end": 198, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 133, + "end": 198, + "name": "STOP", + "source": 0 + }, + { + "begin": 133, + "end": 198, + "name": "tag", + "source": 0, + "value": "5" + }, + { + "begin": 133, + "end": 198, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 186, + "end": 189, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 165, + "end": 191, + "name": "PUSH", + "source": 0, + "value": "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" + }, + { + "begin": 165, + "end": 191, + "name": "AND", + "source": 0 + }, + { + "begin": 165, + "end": 191, + "name": "SELFDESTRUCT", + "source": 0 + } + ] + } + }, + "sourceList": [ + "contracts/contract_lifetime.sol", + "#utility.yul" + ] + }, + "methodIdentifiers": { + "die()": "35f46994" + } + }, + "metadata": "{\"compiler\":{\"version\":\"0.8.21+commit.d9974bed\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"die\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/contract_lifetime.sol\":\"Killable\"},\"evmVersion\":\"shanghai\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":false,\"runs\":200},\"remappings\":[]},\"sources\":{\"contracts/contract_lifetime.sol\":{\"keccak256\":\"0xdf64ae2ed4e5ccfc5181d0a5130424ef00fde2fee461c208bbc25fb02ffd6a59\",\"urls\":[\"bzz-raw://31be55bd8433f2afa420146694e3a1f68bd1eb3d8171fdcc00e6ec0c0c8bdb19\",\"dweb:/ipfs/QmUtuKNtyRRqRxzbLa2FyaDjtjLwnC1vfaPaTLs3rxKCym\"]}},\"version\":1}", + "storageLayout": { + "storage": [], + "types": null + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + } + }, + "NestedCreation": { + "abi": [ + { + "inputs": [], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "inputs": [], + "name": "die", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "evm": { + "assembly": " /* \"contracts/contract_lifetime.sol\":202:318 contract NestedCreation is Killable {... */\n mstore(0x40, 0x80)\n /* \"contracts/contract_lifetime.sol\":260:316 constructor() public {... */\n callvalue\n dup1\n iszero\n tag_1\n jumpi\n 0x00\n dup1\n revert\ntag_1:\n pop\n /* \"contracts/contract_lifetime.sol\":295:309 new Killable() */\n mload(0x40)\n tag_4\n swap1\n tag_5\n jump\t// in\ntag_4:\n mload(0x40)\n dup1\n swap2\n sub\n swap1\n 0x00\n create\n dup1\n iszero\n dup1\n iszero\n tag_6\n jumpi\n returndatasize\n 0x00\n dup1\n returndatacopy\n revert(0x00, returndatasize)\ntag_6:\n pop\n /* \"contracts/contract_lifetime.sol\":291:292 k */\n 0x00\n dup1\n /* \"contracts/contract_lifetime.sol\":291:309 k = new Killable() */\n 0x0100\n exp\n dup2\n sload\n dup2\n 0xffffffffffffffffffffffffffffffffffffffff\n mul\n not\n and\n swap1\n dup4\n 0xffffffffffffffffffffffffffffffffffffffff\n and\n mul\n or\n swap1\n sstore\n pop\n /* \"contracts/contract_lifetime.sol\":202:318 contract NestedCreation is Killable {... */\n jump(tag_7)\ntag_5:\n dataSize(sub_1)\n dup1\n dataOffset(sub_1)\n dup4\n codecopy\n add\n swap1\n jump\t// out\ntag_7:\n dataSize(sub_0)\n dup1\n dataOffset(sub_0)\n 0x00\n codecopy\n 0x00\n return\nstop\n\nsub_0: assembly {\n /* \"contracts/contract_lifetime.sol\":202:318 contract NestedCreation is Killable {... */\n mstore(0x40, 0x80)\n callvalue\n dup1\n iszero\n tag_1\n jumpi\n 0x00\n dup1\n revert\n tag_1:\n pop\n jumpi(tag_2, lt(calldatasize, 0x04))\n shr(0xe0, calldataload(0x00))\n dup1\n 0x35f46994\n eq\n tag_3\n jumpi\n tag_2:\n 0x00\n dup1\n revert\n /* \"contracts/contract_lifetime.sol\":133:198 function die() public {... */\n tag_3:\n tag_4\n tag_5\n jump\t// in\n tag_4:\n stop\n tag_5:\n /* \"contracts/contract_lifetime.sol\":186:189 0x0 */\n 0x00\n /* \"contracts/contract_lifetime.sol\":165:191 selfdestruct(payable(0x0)) */\n 0xffffffffffffffffffffffffffffffffffffffff\n and\n selfdestruct\n\n auxdata: 0xa264697066735822122022b5ad5f782b0bc41d4425d4f3537930800b64da0c6d3808b7c1cfc35533989364736f6c63430008150033\n}\n\nsub_1: assembly {\n /* \"contracts/contract_lifetime.sol\":109:200 contract Killable {... */\n mstore(0x40, 0x80)\n callvalue\n dup1\n iszero\n tag_1\n jumpi\n 0x00\n dup1\n revert\n tag_1:\n pop\n dataSize(sub_0)\n dup1\n dataOffset(sub_0)\n 0x00\n codecopy\n 0x00\n return\n stop\n\n sub_0: assembly {\n /* \"contracts/contract_lifetime.sol\":109:200 contract Killable {... */\n mstore(0x40, 0x80)\n callvalue\n dup1\n iszero\n tag_1\n jumpi\n 0x00\n dup1\n revert\n tag_1:\n pop\n jumpi(tag_2, lt(calldatasize, 0x04))\n shr(0xe0, calldataload(0x00))\n dup1\n 0x35f46994\n eq\n tag_3\n jumpi\n tag_2:\n 0x00\n dup1\n revert\n /* \"contracts/contract_lifetime.sol\":133:198 function die() public {... */\n tag_3:\n tag_4\n tag_5\n jump\t// in\n tag_4:\n stop\n tag_5:\n /* \"contracts/contract_lifetime.sol\":186:189 0x0 */\n 0x00\n /* \"contracts/contract_lifetime.sol\":165:191 selfdestruct(payable(0x0)) */\n 0xffffffffffffffffffffffffffffffffffffffff\n and\n selfdestruct\n\n auxdata: 0xa2646970667358221220aac49067c690fc4a7a711ec18c9a8b6accf3004cea6deef0a7f51a029997a97e64736f6c63430008150033\n }\n}\n", + "bytecode": { + "functionDebugData": { + "@_37": { + "entryPoint": null, + "id": 37, + "parameterSlots": 0, + "returnSlots": 0 + } + }, + "generatedSources": [], + "linkReferences": {}, + "object": "608060405234801561000f575f80fd5b5060405161001c90610079565b604051809103905ff080158015610035573d5f803e3d5ffd5b505f806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550610085565b609c8061011283390190565b6081806100915f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c806335f4699414602a575b5f80fd5b60306032565b005b5f73ffffffffffffffffffffffffffffffffffffffff16fffea264697066735822122022b5ad5f782b0bc41d4425d4f3537930800b64da0c6d3808b7c1cfc35533989364736f6c634300081500336080604052348015600e575f80fd5b5060818061001b5f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c806335f4699414602a575b5f80fd5b60306032565b005b5f73ffffffffffffffffffffffffffffffffffffffff16fffea2646970667358221220aac49067c690fc4a7a711ec18c9a8b6accf3004cea6deef0a7f51a029997a97e64736f6c63430008150033", + "opcodes": "PUSH1 0x80 PUSH1 0x40 MSTORE CALLVALUE DUP1 ISZERO PUSH2 0xF JUMPI PUSH0 DUP1 REVERT JUMPDEST POP PUSH1 0x40 MLOAD PUSH2 0x1C SWAP1 PUSH2 0x79 JUMP JUMPDEST PUSH1 0x40 MLOAD DUP1 SWAP2 SUB SWAP1 PUSH0 CREATE DUP1 ISZERO DUP1 ISZERO PUSH2 0x35 JUMPI RETURNDATASIZE PUSH0 DUP1 RETURNDATACOPY RETURNDATASIZE PUSH0 REVERT JUMPDEST POP PUSH0 DUP1 PUSH2 0x100 EXP DUP2 SLOAD DUP2 PUSH20 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF MUL NOT AND SWAP1 DUP4 PUSH20 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF AND MUL OR SWAP1 SSTORE POP PUSH2 0x85 JUMP JUMPDEST PUSH1 0x9C DUP1 PUSH2 0x112 DUP4 CODECOPY ADD SWAP1 JUMP JUMPDEST PUSH1 0x81 DUP1 PUSH2 0x91 PUSH0 CODECOPY PUSH0 RETURN INVALID PUSH1 0x80 PUSH1 0x40 MSTORE CALLVALUE DUP1 ISZERO PUSH1 0xE JUMPI PUSH0 DUP1 REVERT JUMPDEST POP PUSH1 0x4 CALLDATASIZE LT PUSH1 0x26 JUMPI PUSH0 CALLDATALOAD PUSH1 0xE0 SHR DUP1 PUSH4 0x35F46994 EQ PUSH1 0x2A JUMPI JUMPDEST PUSH0 DUP1 REVERT JUMPDEST PUSH1 0x30 PUSH1 0x32 JUMP JUMPDEST STOP JUMPDEST PUSH0 PUSH20 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF AND SELFDESTRUCT INVALID LOG2 PUSH5 0x6970667358 0x22 SLT KECCAK256 0x22 0xB5 0xAD PUSH0 PUSH25 0x2B0BC41D4425D4F3537930800B64DA0C6D3808B7C1CFC35533 SWAP9 SWAP4 PUSH5 0x736F6C6343 STOP ADDMOD ISZERO STOP CALLER PUSH1 0x80 PUSH1 0x40 MSTORE CALLVALUE DUP1 ISZERO PUSH1 0xE JUMPI PUSH0 DUP1 REVERT JUMPDEST POP PUSH1 0x81 DUP1 PUSH2 0x1B PUSH0 CODECOPY PUSH0 RETURN INVALID PUSH1 0x80 PUSH1 0x40 MSTORE CALLVALUE DUP1 ISZERO PUSH1 0xE JUMPI PUSH0 DUP1 REVERT JUMPDEST POP PUSH1 0x4 CALLDATASIZE LT PUSH1 0x26 JUMPI PUSH0 CALLDATALOAD PUSH1 0xE0 SHR DUP1 PUSH4 0x35F46994 EQ PUSH1 0x2A JUMPI JUMPDEST PUSH0 DUP1 REVERT JUMPDEST PUSH1 0x30 PUSH1 0x32 JUMP JUMPDEST STOP JUMPDEST PUSH0 PUSH20 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF AND SELFDESTRUCT INVALID LOG2 PUSH5 0x6970667358 0x22 SLT KECCAK256 0xAA 0xC4 SWAP1 PUSH8 0xC690FC4A7A711EC1 DUP13 SWAP11 DUP12 PUSH11 0xCCF3004CEA6DEEF0A7F51A MUL SWAP10 SWAP8 0xA9 PUSH31 0x64736F6C634300081500330000000000000000000000000000000000000000 ", + "sourceMap": "202:116:0:-:0;;;260:56;;;;;;;;;;295:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;291:1;;:18;;;;;;;;;;;;;;;;;;202:116;;;;;;;;;;:::o;:::-;;;;;;;" + }, + "deployedBytecode": { + "functionDebugData": { + "@die_20": { + "entryPoint": 50, + "id": 20, + "parameterSlots": 0, + "returnSlots": 0 + } + }, + "generatedSources": [], + "immutableReferences": {}, + "linkReferences": {}, + "object": "6080604052348015600e575f80fd5b50600436106026575f3560e01c806335f4699414602a575b5f80fd5b60306032565b005b5f73ffffffffffffffffffffffffffffffffffffffff16fffea264697066735822122022b5ad5f782b0bc41d4425d4f3537930800b64da0c6d3808b7c1cfc35533989364736f6c63430008150033", + "opcodes": "PUSH1 0x80 PUSH1 0x40 MSTORE CALLVALUE DUP1 ISZERO PUSH1 0xE JUMPI PUSH0 DUP1 REVERT JUMPDEST POP PUSH1 0x4 CALLDATASIZE LT PUSH1 0x26 JUMPI PUSH0 CALLDATALOAD PUSH1 0xE0 SHR DUP1 PUSH4 0x35F46994 EQ PUSH1 0x2A JUMPI JUMPDEST PUSH0 DUP1 REVERT JUMPDEST PUSH1 0x30 PUSH1 0x32 JUMP JUMPDEST STOP JUMPDEST PUSH0 PUSH20 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF AND SELFDESTRUCT INVALID LOG2 PUSH5 0x6970667358 0x22 SLT KECCAK256 0x22 0xB5 0xAD PUSH0 PUSH25 0x2B0BC41D4425D4F3537930800B64DA0C6D3808B7C1CFC35533 SWAP9 SWAP4 PUSH5 0x736F6C6343 STOP ADDMOD ISZERO STOP CALLER ", + "sourceMap": "202:116:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;133:65;;;:::i;:::-;;;186:3;165:26;;" + }, + "gasEstimates": { + "creation": { + "codeDepositCost": "25800", + "executionCost": "infinite", + "totalCost": "infinite" + }, + "external": { + "die()": "27720" + } + }, + "legacyAssembly": { + ".code": [ + { + "begin": 202, + "end": 318, + "name": "PUSH", + "source": 0, + "value": "80" + }, + { + "begin": 202, + "end": 318, + "name": "PUSH", + "source": 0, + "value": "40" + }, + { + "begin": 202, + "end": 318, + "name": "MSTORE", + "source": 0 + }, + { + "begin": 260, + "end": 316, + "name": "CALLVALUE", + "source": 0 + }, + { + "begin": 260, + "end": 316, + "name": "DUP1", + "source": 0 + }, + { + "begin": 260, + "end": 316, + "name": "ISZERO", + "source": 0 + }, + { + "begin": 260, + "end": 316, + "name": "PUSH [tag]", + "source": 0, + "value": "1" + }, + { + "begin": 260, + "end": 316, + "name": "JUMPI", + "source": 0 + }, + { + "begin": 260, + "end": 316, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 260, + "end": 316, + "name": "DUP1", + "source": 0 + }, + { + "begin": 260, + "end": 316, + "name": "REVERT", + "source": 0 + }, + { + "begin": 260, + "end": 316, + "name": "tag", + "source": 0, + "value": "1" + }, + { + "begin": 260, + "end": 316, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 260, + "end": 316, + "name": "POP", + "source": 0 + }, + { + "begin": 295, + "end": 309, + "name": "PUSH", + "source": 0, + "value": "40" + }, + { + "begin": 295, + "end": 309, + "name": "MLOAD", + "source": 0 + }, + { + "begin": 295, + "end": 309, + "name": "PUSH [tag]", + "source": 0, + "value": "4" + }, + { + "begin": 295, + "end": 309, + "name": "SWAP1", + "source": 0 + }, + { + "begin": 295, + "end": 309, + "name": "PUSH [tag]", + "source": 0, + "value": "5" + }, + { + "begin": 295, + "end": 309, + "jumpType": "[in]", + "name": "JUMP", + "source": 0 + }, + { + "begin": 295, + "end": 309, + "name": "tag", + "source": 0, + "value": "4" + }, + { + "begin": 295, + "end": 309, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 295, + "end": 309, + "name": "PUSH", + "source": 0, + "value": "40" + }, + { + "begin": 295, + "end": 309, + "name": "MLOAD", + "source": 0 + }, + { + "begin": 295, + "end": 309, + "name": "DUP1", + "source": 0 + }, + { + "begin": 295, + "end": 309, + "name": "SWAP2", + "source": 0 + }, + { + "begin": 295, + "end": 309, + "name": "SUB", + "source": 0 + }, + { + "begin": 295, + "end": 309, + "name": "SWAP1", + "source": 0 + }, + { + "begin": 295, + "end": 309, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 295, + "end": 309, + "name": "CREATE", + "source": 0 + }, + { + "begin": 295, + "end": 309, + "name": "DUP1", + "source": 0 + }, + { + "begin": 295, + "end": 309, + "name": "ISZERO", + "source": 0 + }, + { + "begin": 295, + "end": 309, + "name": "DUP1", + "source": 0 + }, + { + "begin": 295, + "end": 309, + "name": "ISZERO", + "source": 0 + }, + { + "begin": 295, + "end": 309, + "name": "PUSH [tag]", + "source": 0, + "value": "6" + }, + { + "begin": 295, + "end": 309, + "name": "JUMPI", + "source": 0 + }, + { + "begin": 295, + "end": 309, + "name": "RETURNDATASIZE", + "source": 0 + }, + { + "begin": 295, + "end": 309, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 295, + "end": 309, + "name": "DUP1", + "source": 0 + }, + { + "begin": 295, + "end": 309, + "name": "RETURNDATACOPY", + "source": 0 + }, + { + "begin": 295, + "end": 309, + "name": "RETURNDATASIZE", + "source": 0 + }, + { + "begin": 295, + "end": 309, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 295, + "end": 309, + "name": "REVERT", + "source": 0 + }, + { + "begin": 295, + "end": 309, + "name": "tag", + "source": 0, + "value": "6" + }, + { + "begin": 295, + "end": 309, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 295, + "end": 309, + "name": "POP", + "source": 0 + }, + { + "begin": 291, + "end": 292, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 291, + "end": 292, + "name": "DUP1", + "source": 0 + }, + { + "begin": 291, + "end": 309, + "name": "PUSH", + "source": 0, + "value": "100" + }, + { + "begin": 291, + "end": 309, + "name": "EXP", + "source": 0 + }, + { + "begin": 291, + "end": 309, + "name": "DUP2", + "source": 0 + }, + { + "begin": 291, + "end": 309, + "name": "SLOAD", + "source": 0 + }, + { + "begin": 291, + "end": 309, + "name": "DUP2", + "source": 0 + }, + { + "begin": 291, + "end": 309, + "name": "PUSH", + "source": 0, + "value": "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" + }, + { + "begin": 291, + "end": 309, + "name": "MUL", + "source": 0 + }, + { + "begin": 291, + "end": 309, + "name": "NOT", + "source": 0 + }, + { + "begin": 291, + "end": 309, + "name": "AND", + "source": 0 + }, + { + "begin": 291, + "end": 309, + "name": "SWAP1", + "source": 0 + }, + { + "begin": 291, + "end": 309, + "name": "DUP4", + "source": 0 + }, + { + "begin": 291, + "end": 309, + "name": "PUSH", + "source": 0, + "value": "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" + }, + { + "begin": 291, + "end": 309, + "name": "AND", + "source": 0 + }, + { + "begin": 291, + "end": 309, + "name": "MUL", + "source": 0 + }, + { + "begin": 291, + "end": 309, + "name": "OR", + "source": 0 + }, + { + "begin": 291, + "end": 309, + "name": "SWAP1", + "source": 0 + }, + { + "begin": 291, + "end": 309, + "name": "SSTORE", + "source": 0 + }, + { + "begin": 291, + "end": 309, + "name": "POP", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "PUSH [tag]", + "source": 0, + "value": "7" + }, + { + "begin": 202, + "end": 318, + "name": "JUMP", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "tag", + "source": 0, + "value": "5" + }, + { + "begin": 202, + "end": 318, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "PUSH #[$]", + "source": 0, + "value": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "begin": 202, + "end": 318, + "name": "DUP1", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "PUSH [$]", + "source": 0, + "value": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "begin": 202, + "end": 318, + "name": "DUP4", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "CODECOPY", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "ADD", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "SWAP1", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "jumpType": "[out]", + "name": "JUMP", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "tag", + "source": 0, + "value": "7" + }, + { + "begin": 202, + "end": 318, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "PUSH #[$]", + "source": 0, + "value": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "begin": 202, + "end": 318, + "name": "DUP1", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "PUSH [$]", + "source": 0, + "value": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "begin": 202, + "end": 318, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 202, + "end": 318, + "name": "CODECOPY", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 202, + "end": 318, + "name": "RETURN", + "source": 0 + } + ], + ".data": { + "0": { + ".auxdata": "a264697066735822122022b5ad5f782b0bc41d4425d4f3537930800b64da0c6d3808b7c1cfc35533989364736f6c63430008150033", + ".code": [ + { + "begin": 202, + "end": 318, + "name": "PUSH", + "source": 0, + "value": "80" + }, + { + "begin": 202, + "end": 318, + "name": "PUSH", + "source": 0, + "value": "40" + }, + { + "begin": 202, + "end": 318, + "name": "MSTORE", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "CALLVALUE", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "DUP1", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "ISZERO", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "PUSH [tag]", + "source": 0, + "value": "1" + }, + { + "begin": 202, + "end": 318, + "name": "JUMPI", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 202, + "end": 318, + "name": "DUP1", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "REVERT", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "tag", + "source": 0, + "value": "1" + }, + { + "begin": 202, + "end": 318, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "POP", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "PUSH", + "source": 0, + "value": "4" + }, + { + "begin": 202, + "end": 318, + "name": "CALLDATASIZE", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "LT", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "PUSH [tag]", + "source": 0, + "value": "2" + }, + { + "begin": 202, + "end": 318, + "name": "JUMPI", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 202, + "end": 318, + "name": "CALLDATALOAD", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "PUSH", + "source": 0, + "value": "E0" + }, + { + "begin": 202, + "end": 318, + "name": "SHR", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "DUP1", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "PUSH", + "source": 0, + "value": "35F46994" + }, + { + "begin": 202, + "end": 318, + "name": "EQ", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "PUSH [tag]", + "source": 0, + "value": "3" + }, + { + "begin": 202, + "end": 318, + "name": "JUMPI", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "tag", + "source": 0, + "value": "2" + }, + { + "begin": 202, + "end": 318, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 202, + "end": 318, + "name": "DUP1", + "source": 0 + }, + { + "begin": 202, + "end": 318, + "name": "REVERT", + "source": 0 + }, + { + "begin": 133, + "end": 198, + "name": "tag", + "source": 0, + "value": "3" + }, + { + "begin": 133, + "end": 198, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 133, + "end": 198, + "name": "PUSH [tag]", + "source": 0, + "value": "4" + }, + { + "begin": 133, + "end": 198, + "name": "PUSH [tag]", + "source": 0, + "value": "5" + }, + { + "begin": 133, + "end": 198, + "jumpType": "[in]", + "name": "JUMP", + "source": 0 + }, + { + "begin": 133, + "end": 198, + "name": "tag", + "source": 0, + "value": "4" + }, + { + "begin": 133, + "end": 198, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 133, + "end": 198, + "name": "STOP", + "source": 0 + }, + { + "begin": 133, + "end": 198, + "name": "tag", + "source": 0, + "value": "5" + }, + { + "begin": 133, + "end": 198, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 186, + "end": 189, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 165, + "end": 191, + "name": "PUSH", + "source": 0, + "value": "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" + }, + { + "begin": 165, + "end": 191, + "name": "AND", + "source": 0 + }, + { + "begin": 165, + "end": 191, + "name": "SELFDESTRUCT", + "source": 0 + } + ] + }, + "1": { + ".code": [ + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "80" + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "40" + }, + { + "begin": 109, + "end": 200, + "name": "MSTORE", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "CALLVALUE", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "DUP1", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "ISZERO", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH [tag]", + "source": 0, + "value": "1" + }, + { + "begin": 109, + "end": 200, + "name": "JUMPI", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 109, + "end": 200, + "name": "DUP1", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "REVERT", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "tag", + "source": 0, + "value": "1" + }, + { + "begin": 109, + "end": 200, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "POP", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH #[$]", + "source": 0, + "value": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "begin": 109, + "end": 200, + "name": "DUP1", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH [$]", + "source": 0, + "value": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 109, + "end": 200, + "name": "CODECOPY", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 109, + "end": 200, + "name": "RETURN", + "source": 0 + } + ], + ".data": { + "0": { + ".auxdata": "a2646970667358221220aac49067c690fc4a7a711ec18c9a8b6accf3004cea6deef0a7f51a029997a97e64736f6c63430008150033", + ".code": [ + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "80" + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "40" + }, + { + "begin": 109, + "end": 200, + "name": "MSTORE", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "CALLVALUE", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "DUP1", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "ISZERO", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH [tag]", + "source": 0, + "value": "1" + }, + { + "begin": 109, + "end": 200, + "name": "JUMPI", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 109, + "end": 200, + "name": "DUP1", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "REVERT", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "tag", + "source": 0, + "value": "1" + }, + { + "begin": 109, + "end": 200, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "POP", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "4" + }, + { + "begin": 109, + "end": 200, + "name": "CALLDATASIZE", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "LT", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH [tag]", + "source": 0, + "value": "2" + }, + { + "begin": 109, + "end": 200, + "name": "JUMPI", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 109, + "end": 200, + "name": "CALLDATALOAD", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "E0" + }, + { + "begin": 109, + "end": 200, + "name": "SHR", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "DUP1", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "35F46994" + }, + { + "begin": 109, + "end": 200, + "name": "EQ", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH [tag]", + "source": 0, + "value": "3" + }, + { + "begin": 109, + "end": 200, + "name": "JUMPI", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "tag", + "source": 0, + "value": "2" + }, + { + "begin": 109, + "end": 200, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 109, + "end": 200, + "name": "DUP1", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "REVERT", + "source": 0 + }, + { + "begin": 133, + "end": 198, + "name": "tag", + "source": 0, + "value": "3" + }, + { + "begin": 133, + "end": 198, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 133, + "end": 198, + "name": "PUSH [tag]", + "source": 0, + "value": "4" + }, + { + "begin": 133, + "end": 198, + "name": "PUSH [tag]", + "source": 0, + "value": "5" + }, + { + "begin": 133, + "end": 198, + "jumpType": "[in]", + "name": "JUMP", + "source": 0 + }, + { + "begin": 133, + "end": 198, + "name": "tag", + "source": 0, + "value": "4" + }, + { + "begin": 133, + "end": 198, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 133, + "end": 198, + "name": "STOP", + "source": 0 + }, + { + "begin": 133, + "end": 198, + "name": "tag", + "source": 0, + "value": "5" + }, + { + "begin": 133, + "end": 198, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 186, + "end": 189, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 165, + "end": 191, + "name": "PUSH", + "source": 0, + "value": "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" + }, + { + "begin": 165, + "end": 191, + "name": "AND", + "source": 0 + }, + { + "begin": 165, + "end": 191, + "name": "SELFDESTRUCT", + "source": 0 + } + ] + } + } + } + }, + "sourceList": [ + "contracts/contract_lifetime.sol", + "#utility.yul" + ] + }, + "methodIdentifiers": { + "die()": "35f46994" + } + }, + "metadata": "{\"compiler\":{\"version\":\"0.8.21+commit.d9974bed\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"die\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/contract_lifetime.sol\":\"NestedCreation\"},\"evmVersion\":\"shanghai\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":false,\"runs\":200},\"remappings\":[]},\"sources\":{\"contracts/contract_lifetime.sol\":{\"keccak256\":\"0xdf64ae2ed4e5ccfc5181d0a5130424ef00fde2fee461c208bbc25fb02ffd6a59\",\"urls\":[\"bzz-raw://31be55bd8433f2afa420146694e3a1f68bd1eb3d8171fdcc00e6ec0c0c8bdb19\",\"dweb:/ipfs/QmUtuKNtyRRqRxzbLa2FyaDjtjLwnC1vfaPaTLs3rxKCym\"]}},\"version\":1}", + "storageLayout": { + "storage": [ + { + "astId": 26, + "contract": "contracts/contract_lifetime.sol:NestedCreation", + "label": "k", + "offset": 0, + "slot": "0", + "type": "t_contract(Killable)21" + } + ], + "types": { + "t_contract(Killable)21": { + "encoding": "inplace", + "label": "contract Killable", + "numberOfBytes": "20" + } + } + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + } + }, + "NestedCreationFail": { + "abi": [ + { + "inputs": [], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "inputs": [], + "name": "die", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "evm": { + "assembly": " /* \"contracts/contract_lifetime.sol\":320:542 contract NestedCreationFail is Killable {... */\n mstore(0x40, 0x80)\n /* \"contracts/contract_lifetime.sol\":366:540 constructor() public {... */\n callvalue\n dup1\n iszero\n tag_1\n jumpi\n 0x00\n dup1\n revert\ntag_1:\n pop\n /* \"contracts/contract_lifetime.sol\":401:425 new FailingConstructor() */\n mload(0x40)\n tag_4\n swap1\n tag_5\n jump\t// in\ntag_4:\n mload(0x40)\n dup1\n swap2\n sub\n swap1\n 0x00\n create\n dup1\n iszero\n tag_6\n jumpi\n 0x01\ntag_6:\n /* \"contracts/contract_lifetime.sol\":397:497 try new FailingConstructor() returns (FailingConstructor k) {} catch {... */\n iszero\n tag_11\n jumpi\n /* \"contracts/contract_lifetime.sol\":426:459 returns (FailingConstructor k) {} */\n pop\n /* \"contracts/contract_lifetime.sol\":397:497 try new FailingConstructor() returns (FailingConstructor k) {} catch {... */\ntag_11:\n /* \"contracts/contract_lifetime.sol\":506:516 Killable k */\n 0x00\n /* \"contracts/contract_lifetime.sol\":519:533 new Killable() */\n mload(0x40)\n tag_12\n swap1\n tag_13\n jump\t// in\ntag_12:\n mload(0x40)\n dup1\n swap2\n sub\n swap1\n 0x00\n create\n dup1\n iszero\n dup1\n iszero\n tag_14\n jumpi\n returndatasize\n 0x00\n dup1\n returndatacopy\n revert(0x00, returndatasize)\ntag_14:\n pop\n /* \"contracts/contract_lifetime.sol\":506:533 Killable k = new Killable() */\n swap1\n pop\n /* \"contracts/contract_lifetime.sol\":387:540 {... */\n pop\n /* \"contracts/contract_lifetime.sol\":320:542 contract NestedCreationFail is Killable {... */\n jump(tag_15)\ntag_5:\n dataSize(sub_1)\n dup1\n dataOffset(sub_1)\n dup4\n codecopy\n add\n swap1\n jump\t// out\ntag_13:\n dataSize(sub_2)\n dup1\n dataOffset(sub_2)\n dup4\n codecopy\n add\n swap1\n jump\t// out\ntag_15:\n dataSize(sub_0)\n dup1\n dataOffset(sub_0)\n 0x00\n codecopy\n 0x00\n return\nstop\n\nsub_0: assembly {\n /* \"contracts/contract_lifetime.sol\":320:542 contract NestedCreationFail is Killable {... */\n mstore(0x40, 0x80)\n callvalue\n dup1\n iszero\n tag_1\n jumpi\n 0x00\n dup1\n revert\n tag_1:\n pop\n jumpi(tag_2, lt(calldatasize, 0x04))\n shr(0xe0, calldataload(0x00))\n dup1\n 0x35f46994\n eq\n tag_3\n jumpi\n tag_2:\n 0x00\n dup1\n revert\n /* \"contracts/contract_lifetime.sol\":133:198 function die() public {... */\n tag_3:\n tag_4\n tag_5\n jump\t// in\n tag_4:\n stop\n tag_5:\n /* \"contracts/contract_lifetime.sol\":186:189 0x0 */\n 0x00\n /* \"contracts/contract_lifetime.sol\":165:191 selfdestruct(payable(0x0)) */\n 0xffffffffffffffffffffffffffffffffffffffff\n and\n selfdestruct\n\n auxdata: 0xa264697066735822122005e088379ce3c7f9582da2f32848f32e2a0e0351d10b82981d122e2f0ac9963664736f6c63430008150033\n}\n\nsub_1: assembly {\n /* \"contracts/contract_lifetime.sol\":25:107 contract FailingConstructor {... */\n mstore(0x40, 0x80)\n /* \"contracts/contract_lifetime.sol\":59:105 constructor() public {... */\n callvalue\n dup1\n iszero\n tag_1\n jumpi\n 0x00\n dup1\n revert\n tag_1:\n /* \"contracts/contract_lifetime.sol\":90:98 revert() */\n 0x00\n dup1\n revert\n stop\n\n sub_0: assembly {\n /* \"contracts/contract_lifetime.sol\":25:107 contract FailingConstructor {... */\n mstore(0x40, 0x80)\n 0x00\n dup1\n revert\n\n auxdata: 0xa2646970667358221220e069b7a08f49be425c056ed0e7009fc31d74ca63d855a9abd28d07edcf2f9cd864736f6c63430008150033\n }\n}\n\nsub_2: assembly {\n /* \"contracts/contract_lifetime.sol\":109:200 contract Killable {... */\n mstore(0x40, 0x80)\n callvalue\n dup1\n iszero\n tag_1\n jumpi\n 0x00\n dup1\n revert\n tag_1:\n pop\n dataSize(sub_0)\n dup1\n dataOffset(sub_0)\n 0x00\n codecopy\n 0x00\n return\n stop\n\n sub_0: assembly {\n /* \"contracts/contract_lifetime.sol\":109:200 contract Killable {... */\n mstore(0x40, 0x80)\n callvalue\n dup1\n iszero\n tag_1\n jumpi\n 0x00\n dup1\n revert\n tag_1:\n pop\n jumpi(tag_2, lt(calldatasize, 0x04))\n shr(0xe0, calldataload(0x00))\n dup1\n 0x35f46994\n eq\n tag_3\n jumpi\n tag_2:\n 0x00\n dup1\n revert\n /* \"contracts/contract_lifetime.sol\":133:198 function die() public {... */\n tag_3:\n tag_4\n tag_5\n jump\t// in\n tag_4:\n stop\n tag_5:\n /* \"contracts/contract_lifetime.sol\":186:189 0x0 */\n 0x00\n /* \"contracts/contract_lifetime.sol\":165:191 selfdestruct(payable(0x0)) */\n 0xffffffffffffffffffffffffffffffffffffffff\n and\n selfdestruct\n\n auxdata: 0xa2646970667358221220aac49067c690fc4a7a711ec18c9a8b6accf3004cea6deef0a7f51a029997a97e64736f6c63430008150033\n }\n}\n", + "bytecode": { + "functionDebugData": { + "@_65": { + "entryPoint": null, + "id": 65, + "parameterSlots": 0, + "returnSlots": 0 + } + }, + "generatedSources": [], + "linkReferences": {}, + "object": "608060405234801561000f575f80fd5b5060405161001c90610064565b604051809103905ff0801561002e5760015b1561003557505b5f60405161004290610070565b604051809103905ff08015801561005b573d5f803e3d5ffd5b5090505061007c565b60138061010983390190565b609c8061011c83390190565b6081806100885f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c806335f4699414602a575b5f80fd5b60306032565b005b5f73ffffffffffffffffffffffffffffffffffffffff16fffea264697066735822122005e088379ce3c7f9582da2f32848f32e2a0e0351d10b82981d122e2f0ac9963664736f6c634300081500336080604052348015600e575f80fd5b5f80fdfe6080604052348015600e575f80fd5b5060818061001b5f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c806335f4699414602a575b5f80fd5b60306032565b005b5f73ffffffffffffffffffffffffffffffffffffffff16fffea2646970667358221220aac49067c690fc4a7a711ec18c9a8b6accf3004cea6deef0a7f51a029997a97e64736f6c63430008150033", + "opcodes": "PUSH1 0x80 PUSH1 0x40 MSTORE CALLVALUE DUP1 ISZERO PUSH2 0xF JUMPI PUSH0 DUP1 REVERT JUMPDEST POP PUSH1 0x40 MLOAD PUSH2 0x1C SWAP1 PUSH2 0x64 JUMP JUMPDEST PUSH1 0x40 MLOAD DUP1 SWAP2 SUB SWAP1 PUSH0 CREATE DUP1 ISZERO PUSH2 0x2E JUMPI PUSH1 0x1 JUMPDEST ISZERO PUSH2 0x35 JUMPI POP JUMPDEST PUSH0 PUSH1 0x40 MLOAD PUSH2 0x42 SWAP1 PUSH2 0x70 JUMP JUMPDEST PUSH1 0x40 MLOAD DUP1 SWAP2 SUB SWAP1 PUSH0 CREATE DUP1 ISZERO DUP1 ISZERO PUSH2 0x5B JUMPI RETURNDATASIZE PUSH0 DUP1 RETURNDATACOPY RETURNDATASIZE PUSH0 REVERT JUMPDEST POP SWAP1 POP POP PUSH2 0x7C JUMP JUMPDEST PUSH1 0x13 DUP1 PUSH2 0x109 DUP4 CODECOPY ADD SWAP1 JUMP JUMPDEST PUSH1 0x9C DUP1 PUSH2 0x11C DUP4 CODECOPY ADD SWAP1 JUMP JUMPDEST PUSH1 0x81 DUP1 PUSH2 0x88 PUSH0 CODECOPY PUSH0 RETURN INVALID PUSH1 0x80 PUSH1 0x40 MSTORE CALLVALUE DUP1 ISZERO PUSH1 0xE JUMPI PUSH0 DUP1 REVERT JUMPDEST POP PUSH1 0x4 CALLDATASIZE LT PUSH1 0x26 JUMPI PUSH0 CALLDATALOAD PUSH1 0xE0 SHR DUP1 PUSH4 0x35F46994 EQ PUSH1 0x2A JUMPI JUMPDEST PUSH0 DUP1 REVERT JUMPDEST PUSH1 0x30 PUSH1 0x32 JUMP JUMPDEST STOP JUMPDEST PUSH0 PUSH20 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF AND SELFDESTRUCT INVALID LOG2 PUSH5 0x6970667358 0x22 SLT KECCAK256 SDIV 0xE0 DUP9 CALLDATACOPY SWAP13 0xE3 0xC7 0xF9 PC 0x2D LOG2 RETURN 0x28 BASEFEE RETURN 0x2E 0x2A 0xE SUB MLOAD 0xD1 SIGNEXTEND DUP3 SWAP9 SAR SLT 0x2E 0x2F EXP 0xC9 SWAP7 CALLDATASIZE PUSH5 0x736F6C6343 STOP ADDMOD ISZERO STOP CALLER PUSH1 0x80 PUSH1 0x40 MSTORE CALLVALUE DUP1 ISZERO PUSH1 0xE JUMPI PUSH0 DUP1 REVERT JUMPDEST PUSH0 DUP1 REVERT INVALID PUSH1 0x80 PUSH1 0x40 MSTORE CALLVALUE DUP1 ISZERO PUSH1 0xE JUMPI PUSH0 DUP1 REVERT JUMPDEST POP PUSH1 0x81 DUP1 PUSH2 0x1B PUSH0 CODECOPY PUSH0 RETURN INVALID PUSH1 0x80 PUSH1 0x40 MSTORE CALLVALUE DUP1 ISZERO PUSH1 0xE JUMPI PUSH0 DUP1 REVERT JUMPDEST POP PUSH1 0x4 CALLDATASIZE LT PUSH1 0x26 JUMPI PUSH0 CALLDATALOAD PUSH1 0xE0 SHR DUP1 PUSH4 0x35F46994 EQ PUSH1 0x2A JUMPI JUMPDEST PUSH0 DUP1 REVERT JUMPDEST PUSH1 0x30 PUSH1 0x32 JUMP JUMPDEST STOP JUMPDEST PUSH0 PUSH20 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF AND SELFDESTRUCT INVALID LOG2 PUSH5 0x6970667358 0x22 SLT KECCAK256 0xAA 0xC4 SWAP1 PUSH8 0xC690FC4A7A711EC1 DUP13 SWAP11 DUP12 PUSH11 0xCCF3004CEA6DEEF0A7F51A MUL SWAP10 SWAP8 0xA9 PUSH31 0x64736F6C634300081500330000000000000000000000000000000000000000 ", + "sourceMap": "320:222:0:-:0;;;366:174;;;;;;;;;;401:24;;;;;:::i;:::-;;;;;;;;;;;;;;;397:100;;;426:33;397:100;506:10;519:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;506:27;;387:153;320:222;;;;;;;;;;:::o;:::-;;;;;;;;:::o;:::-;;;;;;;" + }, + "deployedBytecode": { + "functionDebugData": { + "@die_20": { + "entryPoint": 50, + "id": 20, + "parameterSlots": 0, + "returnSlots": 0 + } + }, + "generatedSources": [], + "immutableReferences": {}, + "linkReferences": {}, + "object": "6080604052348015600e575f80fd5b50600436106026575f3560e01c806335f4699414602a575b5f80fd5b60306032565b005b5f73ffffffffffffffffffffffffffffffffffffffff16fffea264697066735822122005e088379ce3c7f9582da2f32848f32e2a0e0351d10b82981d122e2f0ac9963664736f6c63430008150033", + "opcodes": "PUSH1 0x80 PUSH1 0x40 MSTORE CALLVALUE DUP1 ISZERO PUSH1 0xE JUMPI PUSH0 DUP1 REVERT JUMPDEST POP PUSH1 0x4 CALLDATASIZE LT PUSH1 0x26 JUMPI PUSH0 CALLDATALOAD PUSH1 0xE0 SHR DUP1 PUSH4 0x35F46994 EQ PUSH1 0x2A JUMPI JUMPDEST PUSH0 DUP1 REVERT JUMPDEST PUSH1 0x30 PUSH1 0x32 JUMP JUMPDEST STOP JUMPDEST PUSH0 PUSH20 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF AND SELFDESTRUCT INVALID LOG2 PUSH5 0x6970667358 0x22 SLT KECCAK256 SDIV 0xE0 DUP9 CALLDATACOPY SWAP13 0xE3 0xC7 0xF9 PC 0x2D LOG2 RETURN 0x28 BASEFEE RETURN 0x2E 0x2A 0xE SUB MLOAD 0xD1 SIGNEXTEND DUP3 SWAP9 SAR SLT 0x2E 0x2F EXP 0xC9 SWAP7 CALLDATASIZE PUSH5 0x736F6C6343 STOP ADDMOD ISZERO STOP CALLER ", + "sourceMap": "320:222:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;133:65;;;:::i;:::-;;;186:3;165:26;;" + }, + "gasEstimates": { + "creation": { + "codeDepositCost": "25800", + "executionCost": "infinite", + "totalCost": "infinite" + }, + "external": { + "die()": "27720" + } + }, + "legacyAssembly": { + ".code": [ + { + "begin": 320, + "end": 542, + "name": "PUSH", + "source": 0, + "value": "80" + }, + { + "begin": 320, + "end": 542, + "name": "PUSH", + "source": 0, + "value": "40" + }, + { + "begin": 320, + "end": 542, + "name": "MSTORE", + "source": 0 + }, + { + "begin": 366, + "end": 540, + "name": "CALLVALUE", + "source": 0 + }, + { + "begin": 366, + "end": 540, + "name": "DUP1", + "source": 0 + }, + { + "begin": 366, + "end": 540, + "name": "ISZERO", + "source": 0 + }, + { + "begin": 366, + "end": 540, + "name": "PUSH [tag]", + "source": 0, + "value": "1" + }, + { + "begin": 366, + "end": 540, + "name": "JUMPI", + "source": 0 + }, + { + "begin": 366, + "end": 540, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 366, + "end": 540, + "name": "DUP1", + "source": 0 + }, + { + "begin": 366, + "end": 540, + "name": "REVERT", + "source": 0 + }, + { + "begin": 366, + "end": 540, + "name": "tag", + "source": 0, + "value": "1" + }, + { + "begin": 366, + "end": 540, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 366, + "end": 540, + "name": "POP", + "source": 0 + }, + { + "begin": 401, + "end": 425, + "name": "PUSH", + "source": 0, + "value": "40" + }, + { + "begin": 401, + "end": 425, + "name": "MLOAD", + "source": 0 + }, + { + "begin": 401, + "end": 425, + "name": "PUSH [tag]", + "source": 0, + "value": "4" + }, + { + "begin": 401, + "end": 425, + "name": "SWAP1", + "source": 0 + }, + { + "begin": 401, + "end": 425, + "name": "PUSH [tag]", + "source": 0, + "value": "5" + }, + { + "begin": 401, + "end": 425, + "jumpType": "[in]", + "name": "JUMP", + "source": 0 + }, + { + "begin": 401, + "end": 425, + "name": "tag", + "source": 0, + "value": "4" + }, + { + "begin": 401, + "end": 425, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 401, + "end": 425, + "name": "PUSH", + "source": 0, + "value": "40" + }, + { + "begin": 401, + "end": 425, + "name": "MLOAD", + "source": 0 + }, + { + "begin": 401, + "end": 425, + "name": "DUP1", + "source": 0 + }, + { + "begin": 401, + "end": 425, + "name": "SWAP2", + "source": 0 + }, + { + "begin": 401, + "end": 425, + "name": "SUB", + "source": 0 + }, + { + "begin": 401, + "end": 425, + "name": "SWAP1", + "source": 0 + }, + { + "begin": 401, + "end": 425, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 401, + "end": 425, + "name": "CREATE", + "source": 0 + }, + { + "begin": 401, + "end": 425, + "name": "DUP1", + "source": 0 + }, + { + "begin": 401, + "end": 425, + "name": "ISZERO", + "source": 0 + }, + { + "begin": 401, + "end": 425, + "name": "PUSH [tag]", + "source": 0, + "value": "6" + }, + { + "begin": 401, + "end": 425, + "name": "JUMPI", + "source": 0 + }, + { + "begin": 401, + "end": 425, + "name": "PUSH", + "source": 0, + "value": "1" + }, + { + "begin": 401, + "end": 425, + "name": "tag", + "source": 0, + "value": "6" + }, + { + "begin": 401, + "end": 425, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 397, + "end": 497, + "name": "ISZERO", + "source": 0 + }, + { + "begin": 397, + "end": 497, + "name": "PUSH [tag]", + "source": 0, + "value": "11" + }, + { + "begin": 397, + "end": 497, + "name": "JUMPI", + "source": 0 + }, + { + "begin": 426, + "end": 459, + "name": "POP", + "source": 0 + }, + { + "begin": 397, + "end": 497, + "name": "tag", + "source": 0, + "value": "11" + }, + { + "begin": 397, + "end": 497, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 506, + "end": 516, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 519, + "end": 533, + "name": "PUSH", + "source": 0, + "value": "40" + }, + { + "begin": 519, + "end": 533, + "name": "MLOAD", + "source": 0 + }, + { + "begin": 519, + "end": 533, + "name": "PUSH [tag]", + "source": 0, + "value": "12" + }, + { + "begin": 519, + "end": 533, + "name": "SWAP1", + "source": 0 + }, + { + "begin": 519, + "end": 533, + "name": "PUSH [tag]", + "source": 0, + "value": "13" + }, + { + "begin": 519, + "end": 533, + "jumpType": "[in]", + "name": "JUMP", + "source": 0 + }, + { + "begin": 519, + "end": 533, + "name": "tag", + "source": 0, + "value": "12" + }, + { + "begin": 519, + "end": 533, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 519, + "end": 533, + "name": "PUSH", + "source": 0, + "value": "40" + }, + { + "begin": 519, + "end": 533, + "name": "MLOAD", + "source": 0 + }, + { + "begin": 519, + "end": 533, + "name": "DUP1", + "source": 0 + }, + { + "begin": 519, + "end": 533, + "name": "SWAP2", + "source": 0 + }, + { + "begin": 519, + "end": 533, + "name": "SUB", + "source": 0 + }, + { + "begin": 519, + "end": 533, + "name": "SWAP1", + "source": 0 + }, + { + "begin": 519, + "end": 533, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 519, + "end": 533, + "name": "CREATE", + "source": 0 + }, + { + "begin": 519, + "end": 533, + "name": "DUP1", + "source": 0 + }, + { + "begin": 519, + "end": 533, + "name": "ISZERO", + "source": 0 + }, + { + "begin": 519, + "end": 533, + "name": "DUP1", + "source": 0 + }, + { + "begin": 519, + "end": 533, + "name": "ISZERO", + "source": 0 + }, + { + "begin": 519, + "end": 533, + "name": "PUSH [tag]", + "source": 0, + "value": "14" + }, + { + "begin": 519, + "end": 533, + "name": "JUMPI", + "source": 0 + }, + { + "begin": 519, + "end": 533, + "name": "RETURNDATASIZE", + "source": 0 + }, + { + "begin": 519, + "end": 533, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 519, + "end": 533, + "name": "DUP1", + "source": 0 + }, + { + "begin": 519, + "end": 533, + "name": "RETURNDATACOPY", + "source": 0 + }, + { + "begin": 519, + "end": 533, + "name": "RETURNDATASIZE", + "source": 0 + }, + { + "begin": 519, + "end": 533, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 519, + "end": 533, + "name": "REVERT", + "source": 0 + }, + { + "begin": 519, + "end": 533, + "name": "tag", + "source": 0, + "value": "14" + }, + { + "begin": 519, + "end": 533, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 519, + "end": 533, + "name": "POP", + "source": 0 + }, + { + "begin": 506, + "end": 533, + "name": "SWAP1", + "source": 0 + }, + { + "begin": 506, + "end": 533, + "name": "POP", + "source": 0 + }, + { + "begin": 387, + "end": 540, + "name": "POP", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "PUSH [tag]", + "source": 0, + "value": "15" + }, + { + "begin": 320, + "end": 542, + "name": "JUMP", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "tag", + "source": 0, + "value": "5" + }, + { + "begin": 320, + "end": 542, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "PUSH #[$]", + "source": 0, + "value": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "begin": 320, + "end": 542, + "name": "DUP1", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "PUSH [$]", + "source": 0, + "value": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "begin": 320, + "end": 542, + "name": "DUP4", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "CODECOPY", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "ADD", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "SWAP1", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "jumpType": "[out]", + "name": "JUMP", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "tag", + "source": 0, + "value": "13" + }, + { + "begin": 320, + "end": 542, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "PUSH #[$]", + "source": 0, + "value": "0000000000000000000000000000000000000000000000000000000000000002" + }, + { + "begin": 320, + "end": 542, + "name": "DUP1", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "PUSH [$]", + "source": 0, + "value": "0000000000000000000000000000000000000000000000000000000000000002" + }, + { + "begin": 320, + "end": 542, + "name": "DUP4", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "CODECOPY", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "ADD", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "SWAP1", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "jumpType": "[out]", + "name": "JUMP", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "tag", + "source": 0, + "value": "15" + }, + { + "begin": 320, + "end": 542, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "PUSH #[$]", + "source": 0, + "value": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "begin": 320, + "end": 542, + "name": "DUP1", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "PUSH [$]", + "source": 0, + "value": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "begin": 320, + "end": 542, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 320, + "end": 542, + "name": "CODECOPY", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 320, + "end": 542, + "name": "RETURN", + "source": 0 + } + ], + ".data": { + "0": { + ".auxdata": "a264697066735822122005e088379ce3c7f9582da2f32848f32e2a0e0351d10b82981d122e2f0ac9963664736f6c63430008150033", + ".code": [ + { + "begin": 320, + "end": 542, + "name": "PUSH", + "source": 0, + "value": "80" + }, + { + "begin": 320, + "end": 542, + "name": "PUSH", + "source": 0, + "value": "40" + }, + { + "begin": 320, + "end": 542, + "name": "MSTORE", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "CALLVALUE", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "DUP1", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "ISZERO", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "PUSH [tag]", + "source": 0, + "value": "1" + }, + { + "begin": 320, + "end": 542, + "name": "JUMPI", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 320, + "end": 542, + "name": "DUP1", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "REVERT", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "tag", + "source": 0, + "value": "1" + }, + { + "begin": 320, + "end": 542, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "POP", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "PUSH", + "source": 0, + "value": "4" + }, + { + "begin": 320, + "end": 542, + "name": "CALLDATASIZE", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "LT", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "PUSH [tag]", + "source": 0, + "value": "2" + }, + { + "begin": 320, + "end": 542, + "name": "JUMPI", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 320, + "end": 542, + "name": "CALLDATALOAD", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "PUSH", + "source": 0, + "value": "E0" + }, + { + "begin": 320, + "end": 542, + "name": "SHR", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "DUP1", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "PUSH", + "source": 0, + "value": "35F46994" + }, + { + "begin": 320, + "end": 542, + "name": "EQ", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "PUSH [tag]", + "source": 0, + "value": "3" + }, + { + "begin": 320, + "end": 542, + "name": "JUMPI", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "tag", + "source": 0, + "value": "2" + }, + { + "begin": 320, + "end": 542, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 320, + "end": 542, + "name": "DUP1", + "source": 0 + }, + { + "begin": 320, + "end": 542, + "name": "REVERT", + "source": 0 + }, + { + "begin": 133, + "end": 198, + "name": "tag", + "source": 0, + "value": "3" + }, + { + "begin": 133, + "end": 198, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 133, + "end": 198, + "name": "PUSH [tag]", + "source": 0, + "value": "4" + }, + { + "begin": 133, + "end": 198, + "name": "PUSH [tag]", + "source": 0, + "value": "5" + }, + { + "begin": 133, + "end": 198, + "jumpType": "[in]", + "name": "JUMP", + "source": 0 + }, + { + "begin": 133, + "end": 198, + "name": "tag", + "source": 0, + "value": "4" + }, + { + "begin": 133, + "end": 198, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 133, + "end": 198, + "name": "STOP", + "source": 0 + }, + { + "begin": 133, + "end": 198, + "name": "tag", + "source": 0, + "value": "5" + }, + { + "begin": 133, + "end": 198, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 186, + "end": 189, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 165, + "end": 191, + "name": "PUSH", + "source": 0, + "value": "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" + }, + { + "begin": 165, + "end": 191, + "name": "AND", + "source": 0 + }, + { + "begin": 165, + "end": 191, + "name": "SELFDESTRUCT", + "source": 0 + } + ] + }, + "1": { + ".code": [ + { + "begin": 25, + "end": 107, + "name": "PUSH", + "source": 0, + "value": "80" + }, + { + "begin": 25, + "end": 107, + "name": "PUSH", + "source": 0, + "value": "40" + }, + { + "begin": 25, + "end": 107, + "name": "MSTORE", + "source": 0 + }, + { + "begin": 59, + "end": 105, + "name": "CALLVALUE", + "source": 0 + }, + { + "begin": 59, + "end": 105, + "name": "DUP1", + "source": 0 + }, + { + "begin": 59, + "end": 105, + "name": "ISZERO", + "source": 0 + }, + { + "begin": 59, + "end": 105, + "name": "PUSH [tag]", + "source": 0, + "value": "1" + }, + { + "begin": 59, + "end": 105, + "name": "JUMPI", + "source": 0 + }, + { + "begin": 59, + "end": 105, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 59, + "end": 105, + "name": "DUP1", + "source": 0 + }, + { + "begin": 59, + "end": 105, + "name": "REVERT", + "source": 0 + }, + { + "begin": 59, + "end": 105, + "name": "tag", + "source": 0, + "value": "1" + }, + { + "begin": 59, + "end": 105, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 90, + "end": 98, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 90, + "end": 98, + "name": "DUP1", + "source": 0 + }, + { + "begin": 90, + "end": 98, + "name": "REVERT", + "source": 0 + } + ], + ".data": { + "0": { + ".auxdata": "a2646970667358221220e069b7a08f49be425c056ed0e7009fc31d74ca63d855a9abd28d07edcf2f9cd864736f6c63430008150033", + ".code": [ + { + "begin": 25, + "end": 107, + "name": "PUSH", + "source": 0, + "value": "80" + }, + { + "begin": 25, + "end": 107, + "name": "PUSH", + "source": 0, + "value": "40" + }, + { + "begin": 25, + "end": 107, + "name": "MSTORE", + "source": 0 + }, + { + "begin": 25, + "end": 107, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 25, + "end": 107, + "name": "DUP1", + "source": 0 + }, + { + "begin": 25, + "end": 107, + "name": "REVERT", + "source": 0 + } + ] + } + } + }, + "2": { + ".code": [ + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "80" + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "40" + }, + { + "begin": 109, + "end": 200, + "name": "MSTORE", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "CALLVALUE", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "DUP1", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "ISZERO", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH [tag]", + "source": 0, + "value": "1" + }, + { + "begin": 109, + "end": 200, + "name": "JUMPI", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 109, + "end": 200, + "name": "DUP1", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "REVERT", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "tag", + "source": 0, + "value": "1" + }, + { + "begin": 109, + "end": 200, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "POP", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH #[$]", + "source": 0, + "value": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "begin": 109, + "end": 200, + "name": "DUP1", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH [$]", + "source": 0, + "value": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 109, + "end": 200, + "name": "CODECOPY", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 109, + "end": 200, + "name": "RETURN", + "source": 0 + } + ], + ".data": { + "0": { + ".auxdata": "a2646970667358221220aac49067c690fc4a7a711ec18c9a8b6accf3004cea6deef0a7f51a029997a97e64736f6c63430008150033", + ".code": [ + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "80" + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "40" + }, + { + "begin": 109, + "end": 200, + "name": "MSTORE", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "CALLVALUE", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "DUP1", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "ISZERO", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH [tag]", + "source": 0, + "value": "1" + }, + { + "begin": 109, + "end": 200, + "name": "JUMPI", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 109, + "end": 200, + "name": "DUP1", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "REVERT", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "tag", + "source": 0, + "value": "1" + }, + { + "begin": 109, + "end": 200, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "POP", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "4" + }, + { + "begin": 109, + "end": 200, + "name": "CALLDATASIZE", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "LT", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH [tag]", + "source": 0, + "value": "2" + }, + { + "begin": 109, + "end": 200, + "name": "JUMPI", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 109, + "end": 200, + "name": "CALLDATALOAD", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "E0" + }, + { + "begin": 109, + "end": 200, + "name": "SHR", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "DUP1", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "35F46994" + }, + { + "begin": 109, + "end": 200, + "name": "EQ", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH [tag]", + "source": 0, + "value": "3" + }, + { + "begin": 109, + "end": 200, + "name": "JUMPI", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "tag", + "source": 0, + "value": "2" + }, + { + "begin": 109, + "end": 200, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 109, + "end": 200, + "name": "DUP1", + "source": 0 + }, + { + "begin": 109, + "end": 200, + "name": "REVERT", + "source": 0 + }, + { + "begin": 133, + "end": 198, + "name": "tag", + "source": 0, + "value": "3" + }, + { + "begin": 133, + "end": 198, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 133, + "end": 198, + "name": "PUSH [tag]", + "source": 0, + "value": "4" + }, + { + "begin": 133, + "end": 198, + "name": "PUSH [tag]", + "source": 0, + "value": "5" + }, + { + "begin": 133, + "end": 198, + "jumpType": "[in]", + "name": "JUMP", + "source": 0 + }, + { + "begin": 133, + "end": 198, + "name": "tag", + "source": 0, + "value": "4" + }, + { + "begin": 133, + "end": 198, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 133, + "end": 198, + "name": "STOP", + "source": 0 + }, + { + "begin": 133, + "end": 198, + "name": "tag", + "source": 0, + "value": "5" + }, + { + "begin": 133, + "end": 198, + "name": "JUMPDEST", + "source": 0 + }, + { + "begin": 186, + "end": 189, + "name": "PUSH", + "source": 0, + "value": "0" + }, + { + "begin": 165, + "end": 191, + "name": "PUSH", + "source": 0, + "value": "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" + }, + { + "begin": 165, + "end": 191, + "name": "AND", + "source": 0 + }, + { + "begin": 165, + "end": 191, + "name": "SELFDESTRUCT", + "source": 0 + } + ] + } + } + } + }, + "sourceList": [ + "contracts/contract_lifetime.sol", + "#utility.yul" + ] + }, + "methodIdentifiers": { + "die()": "35f46994" + } + }, + "metadata": "{\"compiler\":{\"version\":\"0.8.21+commit.d9974bed\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"die\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/contract_lifetime.sol\":\"NestedCreationFail\"},\"evmVersion\":\"shanghai\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":false,\"runs\":200},\"remappings\":[]},\"sources\":{\"contracts/contract_lifetime.sol\":{\"keccak256\":\"0xdf64ae2ed4e5ccfc5181d0a5130424ef00fde2fee461c208bbc25fb02ffd6a59\",\"urls\":[\"bzz-raw://31be55bd8433f2afa420146694e3a1f68bd1eb3d8171fdcc00e6ec0c0c8bdb19\",\"dweb:/ipfs/QmUtuKNtyRRqRxzbLa2FyaDjtjLwnC1vfaPaTLs3rxKCym\"]}},\"version\":1}", + "storageLayout": { + "storage": [], + "types": null + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + } + } + } + }, + "errors": [ + { + "component": "general", + "errorCode": "1878", + "formattedMessage": "Warning: SPDX license identifier not provided in source file. Before publishing, consider adding a comment containing \"SPDX-License-Identifier: \" to each source file. Use \"SPDX-License-Identifier: UNLICENSED\" for non-open-source code. Please see https://spdx.org for more information.\n--> contracts/contract_lifetime.sol\n\n", + "message": "SPDX license identifier not provided in source file. Before publishing, consider adding a comment containing \"SPDX-License-Identifier: \" to each source file. Use \"SPDX-License-Identifier: UNLICENSED\" for non-open-source code. Please see https://spdx.org for more information.", + "severity": "warning", + "sourceLocation": { + "end": -1, + "file": "contracts/contract_lifetime.sol", + "start": -1 + }, + "type": "Warning" + }, + { + "component": "general", + "errorCode": "2519", + "formattedMessage": "Warning: This declaration shadows an existing declaration.\n --> contracts/contract_lifetime.sol:24:47:\n |\n24 | try new FailingConstructor() returns (FailingConstructor k) {} catch {\n | ^^^^^^^^^^^^^^^^^^^^\nNote: The shadowed declaration is here:\n --> contracts/contract_lifetime.sol:27:9:\n |\n27 | Killable k = new Killable();\n | ^^^^^^^^^^\n\n", + "message": "This declaration shadows an existing declaration.", + "secondarySourceLocations": [ + { + "end": 516, + "file": "contracts/contract_lifetime.sol", + "message": "The shadowed declaration is here:", + "start": 506 + } + ], + "severity": "warning", + "sourceLocation": { + "end": 455, + "file": "contracts/contract_lifetime.sol", + "start": 435 + }, + "type": "Warning" + }, + { + "component": "general", + "errorCode": "2462", + "formattedMessage": "Warning: Visibility for constructor is ignored. If you want the contract to be non-deployable, making it \"abstract\" is sufficient.\n --> contracts/contract_lifetime.sol:4:5:\n |\n4 | constructor() public {\n | ^ (Relevant source part starts here and spans across multiple lines).\n\n", + "message": "Visibility for constructor is ignored. If you want the contract to be non-deployable, making it \"abstract\" is sufficient.", + "severity": "warning", + "sourceLocation": { + "end": 105, + "file": "contracts/contract_lifetime.sol", + "start": 59 + }, + "type": "Warning" + }, + { + "component": "general", + "errorCode": "5159", + "formattedMessage": "Warning: \"selfdestruct\" has been deprecated. The underlying opcode will eventually undergo breaking changes, and its use is not recommended.\n --> contracts/contract_lifetime.sol:11:9:\n |\n11 | selfdestruct(payable(0x0));\n | ^^^^^^^^^^^^\n\n", + "message": "\"selfdestruct\" has been deprecated. The underlying opcode will eventually undergo breaking changes, and its use is not recommended.", + "severity": "warning", + "sourceLocation": { + "end": 177, + "file": "contracts/contract_lifetime.sol", + "start": 165 + }, + "type": "Warning" + }, + { + "component": "general", + "errorCode": "2462", + "formattedMessage": "Warning: Visibility for constructor is ignored. If you want the contract to be non-deployable, making it \"abstract\" is sufficient.\n --> contracts/contract_lifetime.sol:17:5:\n |\n17 | constructor() public {\n | ^ (Relevant source part starts here and spans across multiple lines).\n\n", + "message": "Visibility for constructor is ignored. If you want the contract to be non-deployable, making it \"abstract\" is sufficient.", + "severity": "warning", + "sourceLocation": { + "end": 316, + "file": "contracts/contract_lifetime.sol", + "start": 260 + }, + "type": "Warning" + }, + { + "component": "general", + "errorCode": "2462", + "formattedMessage": "Warning: Visibility for constructor is ignored. If you want the contract to be non-deployable, making it \"abstract\" is sufficient.\n --> contracts/contract_lifetime.sol:23:5:\n |\n23 | constructor() public {\n | ^ (Relevant source part starts here and spans across multiple lines).\n\n", + "message": "Visibility for constructor is ignored. If you want the contract to be non-deployable, making it \"abstract\" is sufficient.", + "severity": "warning", + "sourceLocation": { + "end": 540, + "file": "contracts/contract_lifetime.sol", + "start": 366 + }, + "type": "Warning" + }, + { + "component": "general", + "errorCode": "5667", + "formattedMessage": "Warning: Unused try/catch parameter. Remove or comment out the variable name to silence this warning.\n --> contracts/contract_lifetime.sol:24:47:\n |\n24 | try new FailingConstructor() returns (FailingConstructor k) {} catch {\n | ^^^^^^^^^^^^^^^^^^^^\n\n", + "message": "Unused try/catch parameter. Remove or comment out the variable name to silence this warning.", + "severity": "warning", + "sourceLocation": { + "end": 455, + "file": "contracts/contract_lifetime.sol", + "start": 435 + }, + "type": "Warning" + }, + { + "component": "general", + "errorCode": "2072", + "formattedMessage": "Warning: Unused local variable.\n --> contracts/contract_lifetime.sol:27:9:\n |\n27 | Killable k = new Killable();\n | ^^^^^^^^^^\n\n", + "message": "Unused local variable.", + "severity": "warning", + "sourceLocation": { + "end": 516, + "file": "contracts/contract_lifetime.sol", + "start": 506 + }, + "type": "Warning" + } + ], + "sources": { + "contracts/contract_lifetime.sol": { + "ast": { + "absolutePath": "contracts/contract_lifetime.sol", + "exportedSymbols": { + "FailingConstructor": [ + 9 + ], + "Killable": [ + 21 + ], + "NestedCreation": [ + 38 + ], + "NestedCreationFail": [ + 66 + ] + }, + "id": 67, + "nodeType": "SourceUnit", + "nodes": [ + { + "id": 1, + "literals": [ + "solidity", + "0.8", + ".21" + ], + "nodeType": "PragmaDirective", + "src": "0:23:0" + }, + { + "abstract": false, + "baseContracts": [], + "canonicalName": "FailingConstructor", + "contractDependencies": [], + "contractKind": "contract", + "fullyImplemented": true, + "id": 9, + "linearizedBaseContracts": [ + 9 + ], + "name": "FailingConstructor", + "nameLocation": "34:18:0", + "nodeType": "ContractDefinition", + "nodes": [ + { + "body": { + "id": 7, + "nodeType": "Block", + "src": "80:25:0", + "statements": [ + { + "expression": { + "arguments": [], + "expression": { + "argumentTypes": [], + "id": 4, + "name": "revert", + "nodeType": "Identifier", + "overloadedDeclarations": [ + 4294967277, + 4294967277 + ], + "referencedDeclaration": 4294967277, + "src": "90:6:0", + "typeDescriptions": { + "typeIdentifier": "t_function_revert_pure$__$returns$__$", + "typeString": "function () pure" + } + }, + "id": 5, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "nameLocations": [], + "names": [], + "nodeType": "FunctionCall", + "src": "90:8:0", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_tuple$__$", + "typeString": "tuple()" + } + }, + "id": 6, + "nodeType": "ExpressionStatement", + "src": "90:8:0" + } + ] + }, + "id": 8, + "implemented": true, + "kind": "constructor", + "modifiers": [], + "name": "", + "nameLocation": "-1:-1:-1", + "nodeType": "FunctionDefinition", + "parameters": { + "id": 2, + "nodeType": "ParameterList", + "parameters": [], + "src": "70:2:0" + }, + "returnParameters": { + "id": 3, + "nodeType": "ParameterList", + "parameters": [], + "src": "80:0:0" + }, + "scope": 9, + "src": "59:46:0", + "stateMutability": "nonpayable", + "virtual": false, + "visibility": "public" + } + ], + "scope": 67, + "src": "25:82:0", + "usedErrors": [], + "usedEvents": [] + }, + { + "abstract": false, + "baseContracts": [], + "canonicalName": "Killable", + "contractDependencies": [], + "contractKind": "contract", + "fullyImplemented": true, + "id": 21, + "linearizedBaseContracts": [ + 21 + ], + "name": "Killable", + "nameLocation": "118:8:0", + "nodeType": "ContractDefinition", + "nodes": [ + { + "body": { + "id": 19, + "nodeType": "Block", + "src": "155:43:0", + "statements": [ + { + "expression": { + "arguments": [ + { + "arguments": [ + { + "hexValue": "307830", + "id": 15, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "186:3:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_0_by_1", + "typeString": "int_const 0" + }, + "value": "0x0" + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_rational_0_by_1", + "typeString": "int_const 0" + } + ], + "id": 14, + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "nodeType": "ElementaryTypeNameExpression", + "src": "178:8:0", + "typeDescriptions": { + "typeIdentifier": "t_type$_t_address_payable_$", + "typeString": "type(address payable)" + }, + "typeName": { + "id": 13, + "name": "address", + "nodeType": "ElementaryTypeName", + "src": "178:8:0", + "stateMutability": "payable", + "typeDescriptions": {} + } + }, + "id": 16, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "typeConversion", + "lValueRequested": false, + "nameLocations": [], + "names": [], + "nodeType": "FunctionCall", + "src": "178:12:0", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_address_payable", + "typeString": "address payable" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_address_payable", + "typeString": "address payable" + } + ], + "id": 12, + "name": "selfdestruct", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 4294967275, + "src": "165:12:0", + "typeDescriptions": { + "typeIdentifier": "t_function_selfdestruct_nonpayable$_t_address_payable_$returns$__$", + "typeString": "function (address payable)" + } + }, + "id": 17, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "nameLocations": [], + "names": [], + "nodeType": "FunctionCall", + "src": "165:26:0", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_tuple$__$", + "typeString": "tuple()" + } + }, + "id": 18, + "nodeType": "ExpressionStatement", + "src": "165:26:0" + } + ] + }, + "functionSelector": "35f46994", + "id": 20, + "implemented": true, + "kind": "function", + "modifiers": [], + "name": "die", + "nameLocation": "142:3:0", + "nodeType": "FunctionDefinition", + "parameters": { + "id": 10, + "nodeType": "ParameterList", + "parameters": [], + "src": "145:2:0" + }, + "returnParameters": { + "id": 11, + "nodeType": "ParameterList", + "parameters": [], + "src": "155:0:0" + }, + "scope": 21, + "src": "133:65:0", + "stateMutability": "nonpayable", + "virtual": false, + "visibility": "public" + } + ], + "scope": 67, + "src": "109:91:0", + "usedErrors": [], + "usedEvents": [] + }, + { + "abstract": false, + "baseContracts": [ + { + "baseName": { + "id": 22, + "name": "Killable", + "nameLocations": [ + "229:8:0" + ], + "nodeType": "IdentifierPath", + "referencedDeclaration": 21, + "src": "229:8:0" + }, + "id": 23, + "nodeType": "InheritanceSpecifier", + "src": "229:8:0" + } + ], + "canonicalName": "NestedCreation", + "contractDependencies": [ + 21 + ], + "contractKind": "contract", + "fullyImplemented": true, + "id": 38, + "linearizedBaseContracts": [ + 38, + 21 + ], + "name": "NestedCreation", + "nameLocation": "211:14:0", + "nodeType": "ContractDefinition", + "nodes": [ + { + "constant": false, + "id": 26, + "mutability": "mutable", + "name": "k", + "nameLocation": "253:1:0", + "nodeType": "VariableDeclaration", + "scope": 38, + "src": "244:10:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_contract$_Killable_$21", + "typeString": "contract Killable" + }, + "typeName": { + "id": 25, + "nodeType": "UserDefinedTypeName", + "pathNode": { + "id": 24, + "name": "Killable", + "nameLocations": [ + "244:8:0" + ], + "nodeType": "IdentifierPath", + "referencedDeclaration": 21, + "src": "244:8:0" + }, + "referencedDeclaration": 21, + "src": "244:8:0", + "typeDescriptions": { + "typeIdentifier": "t_contract$_Killable_$21", + "typeString": "contract Killable" + } + }, + "visibility": "internal" + }, + { + "body": { + "id": 36, + "nodeType": "Block", + "src": "281:35:0", + "statements": [ + { + "expression": { + "id": 34, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftHandSide": { + "id": 29, + "name": "k", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 26, + "src": "291:1:0", + "typeDescriptions": { + "typeIdentifier": "t_contract$_Killable_$21", + "typeString": "contract Killable" + } + }, + "nodeType": "Assignment", + "operator": "=", + "rightHandSide": { + "arguments": [], + "expression": { + "argumentTypes": [], + "id": 32, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "nodeType": "NewExpression", + "src": "295:12:0", + "typeDescriptions": { + "typeIdentifier": "t_function_creation_nonpayable$__$returns$_t_contract$_Killable_$21_$", + "typeString": "function () returns (contract Killable)" + }, + "typeName": { + "id": 31, + "nodeType": "UserDefinedTypeName", + "pathNode": { + "id": 30, + "name": "Killable", + "nameLocations": [ + "299:8:0" + ], + "nodeType": "IdentifierPath", + "referencedDeclaration": 21, + "src": "299:8:0" + }, + "referencedDeclaration": 21, + "src": "299:8:0", + "typeDescriptions": { + "typeIdentifier": "t_contract$_Killable_$21", + "typeString": "contract Killable" + } + } + }, + "id": 33, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "nameLocations": [], + "names": [], + "nodeType": "FunctionCall", + "src": "295:14:0", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_contract$_Killable_$21", + "typeString": "contract Killable" + } + }, + "src": "291:18:0", + "typeDescriptions": { + "typeIdentifier": "t_contract$_Killable_$21", + "typeString": "contract Killable" + } + }, + "id": 35, + "nodeType": "ExpressionStatement", + "src": "291:18:0" + } + ] + }, + "id": 37, + "implemented": true, + "kind": "constructor", + "modifiers": [], + "name": "", + "nameLocation": "-1:-1:-1", + "nodeType": "FunctionDefinition", + "parameters": { + "id": 27, + "nodeType": "ParameterList", + "parameters": [], + "src": "271:2:0" + }, + "returnParameters": { + "id": 28, + "nodeType": "ParameterList", + "parameters": [], + "src": "281:0:0" + }, + "scope": 38, + "src": "260:56:0", + "stateMutability": "nonpayable", + "virtual": false, + "visibility": "public" + } + ], + "scope": 67, + "src": "202:116:0", + "usedErrors": [], + "usedEvents": [] + }, + { + "abstract": false, + "baseContracts": [ + { + "baseName": { + "id": 39, + "name": "Killable", + "nameLocations": [ + "351:8:0" + ], + "nodeType": "IdentifierPath", + "referencedDeclaration": 21, + "src": "351:8:0" + }, + "id": 40, + "nodeType": "InheritanceSpecifier", + "src": "351:8:0" + } + ], + "canonicalName": "NestedCreationFail", + "contractDependencies": [ + 9, + 21 + ], + "contractKind": "contract", + "fullyImplemented": true, + "id": 66, + "linearizedBaseContracts": [ + 66, + 21 + ], + "name": "NestedCreationFail", + "nameLocation": "329:18:0", + "nodeType": "ContractDefinition", + "nodes": [ + { + "body": { + "id": 64, + "nodeType": "Block", + "src": "387:153:0", + "statements": [ + { + "clauses": [ + { + "block": { + "id": 51, + "nodeType": "Block", + "src": "457:2:0", + "statements": [] + }, + "errorName": "", + "id": 52, + "nodeType": "TryCatchClause", + "parameters": { + "id": 50, + "nodeType": "ParameterList", + "parameters": [ + { + "constant": false, + "id": 49, + "mutability": "mutable", + "name": "k", + "nameLocation": "454:1:0", + "nodeType": "VariableDeclaration", + "scope": 52, + "src": "435:20:0", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_contract$_FailingConstructor_$9", + "typeString": "contract FailingConstructor" + }, + "typeName": { + "id": 48, + "nodeType": "UserDefinedTypeName", + "pathNode": { + "id": 47, + "name": "FailingConstructor", + "nameLocations": [ + "435:18:0" + ], + "nodeType": "IdentifierPath", + "referencedDeclaration": 9, + "src": "435:18:0" + }, + "referencedDeclaration": 9, + "src": "435:18:0", + "typeDescriptions": { + "typeIdentifier": "t_contract$_FailingConstructor_$9", + "typeString": "contract FailingConstructor" + } + }, + "visibility": "internal" + } + ], + "src": "434:22:0" + }, + "src": "426:33:0" + }, + { + "block": { + "id": 53, + "nodeType": "Block", + "src": "466:31:0", + "statements": [] + }, + "errorName": "", + "id": 54, + "nodeType": "TryCatchClause", + "src": "460:37:0" + } + ], + "externalCall": { + "arguments": [], + "expression": { + "argumentTypes": [], + "id": 45, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "nodeType": "NewExpression", + "src": "401:22:0", + "typeDescriptions": { + "typeIdentifier": "t_function_creation_nonpayable$__$returns$_t_contract$_FailingConstructor_$9_$", + "typeString": "function () returns (contract FailingConstructor)" + }, + "typeName": { + "id": 44, + "nodeType": "UserDefinedTypeName", + "pathNode": { + "id": 43, + "name": "FailingConstructor", + "nameLocations": [ + "405:18:0" + ], + "nodeType": "IdentifierPath", + "referencedDeclaration": 9, + "src": "405:18:0" + }, + "referencedDeclaration": 9, + "src": "405:18:0", + "typeDescriptions": { + "typeIdentifier": "t_contract$_FailingConstructor_$9", + "typeString": "contract FailingConstructor" + } + } + }, + "id": 46, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "nameLocations": [], + "names": [], + "nodeType": "FunctionCall", + "src": "401:24:0", + "tryCall": true, + "typeDescriptions": { + "typeIdentifier": "t_contract$_FailingConstructor_$9", + "typeString": "contract FailingConstructor" + } + }, + "id": 55, + "nodeType": "TryStatement", + "src": "397:100:0" + }, + { + "assignments": [ + 58 + ], + "declarations": [ + { + "constant": false, + "id": 58, + "mutability": "mutable", + "name": "k", + "nameLocation": "515:1:0", + "nodeType": "VariableDeclaration", + "scope": 64, + "src": "506:10:0", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_contract$_Killable_$21", + "typeString": "contract Killable" + }, + "typeName": { + "id": 57, + "nodeType": "UserDefinedTypeName", + "pathNode": { + "id": 56, + "name": "Killable", + "nameLocations": [ + "506:8:0" + ], + "nodeType": "IdentifierPath", + "referencedDeclaration": 21, + "src": "506:8:0" + }, + "referencedDeclaration": 21, + "src": "506:8:0", + "typeDescriptions": { + "typeIdentifier": "t_contract$_Killable_$21", + "typeString": "contract Killable" + } + }, + "visibility": "internal" + } + ], + "id": 63, + "initialValue": { + "arguments": [], + "expression": { + "argumentTypes": [], + "id": 61, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "nodeType": "NewExpression", + "src": "519:12:0", + "typeDescriptions": { + "typeIdentifier": "t_function_creation_nonpayable$__$returns$_t_contract$_Killable_$21_$", + "typeString": "function () returns (contract Killable)" + }, + "typeName": { + "id": 60, + "nodeType": "UserDefinedTypeName", + "pathNode": { + "id": 59, + "name": "Killable", + "nameLocations": [ + "523:8:0" + ], + "nodeType": "IdentifierPath", + "referencedDeclaration": 21, + "src": "523:8:0" + }, + "referencedDeclaration": 21, + "src": "523:8:0", + "typeDescriptions": { + "typeIdentifier": "t_contract$_Killable_$21", + "typeString": "contract Killable" + } + } + }, + "id": 62, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "nameLocations": [], + "names": [], + "nodeType": "FunctionCall", + "src": "519:14:0", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_contract$_Killable_$21", + "typeString": "contract Killable" + } + }, + "nodeType": "VariableDeclarationStatement", + "src": "506:27:0" + } + ] + }, + "id": 65, + "implemented": true, + "kind": "constructor", + "modifiers": [], + "name": "", + "nameLocation": "-1:-1:-1", + "nodeType": "FunctionDefinition", + "parameters": { + "id": 41, + "nodeType": "ParameterList", + "parameters": [], + "src": "377:2:0" + }, + "returnParameters": { + "id": 42, + "nodeType": "ParameterList", + "parameters": [], + "src": "387:0:0" + }, + "scope": 66, + "src": "366:174:0", + "stateMutability": "nonpayable", + "virtual": false, + "visibility": "public" + } + ], + "scope": 67, + "src": "320:222:0", + "usedErrors": [], + "usedEvents": [] + } + ], + "src": "0:543:0" + }, + "id": 0 + } + } +} diff --git a/test/samples/local/contract_lifetime/contracts/contracts/contract_lifetime.sol b/test/samples/local/contract_lifetime/contracts/contracts/contract_lifetime.sol new file mode 100644 index 0000000..90eec2b --- /dev/null +++ b/test/samples/local/contract_lifetime/contracts/contracts/contract_lifetime.sol @@ -0,0 +1,29 @@ +pragma solidity 0.8.21; + +contract FailingConstructor { + constructor() public { + revert(); + } +} + +contract Killable { + function die() public { + selfdestruct(payable(0x0)); + } +} + +contract NestedCreation is Killable { + Killable k; + constructor() public { + k = new Killable(); + } +} + +contract NestedCreationFail is Killable { + constructor() public { + try new FailingConstructor() returns (FailingConstructor k) {} catch { + // nada + } + Killable k = new Killable(); + } +} diff --git a/test/samples/local/contract_lifetime/contracts/hardhat.config.js b/test/samples/local/contract_lifetime/contracts/hardhat.config.js new file mode 100644 index 0000000..e32b4fa --- /dev/null +++ b/test/samples/local/contract_lifetime/contracts/hardhat.config.js @@ -0,0 +1,12 @@ +require("@nomicfoundation/hardhat-ethers"); +/** + * @type import('hardhat/config').HardhatUserConfig + */ +module.exports = { + solidity: "0.8.21", + networks: { + localhost: { + url: "http://localhost:7545" + } + } +}; diff --git a/test/samples/local/contract_lifetime/contracts/mktx.ts b/test/samples/local/contract_lifetime/contracts/mktx.ts new file mode 100644 index 0000000..5c5b6b4 --- /dev/null +++ b/test/samples/local/contract_lifetime/contracts/mktx.ts @@ -0,0 +1,40 @@ +import { ethers } from "hardhat"; + +(async function main() { + const FailingConstructor = await ethers.getContractFactory("FailingConstructor"); + + const tx = await FailingConstructor.getDeployTransaction(); + console.error("FailingConstructor bytecode:", tx.data); + + // Failing constructor + try { + const t = await FailingConstructor.deploy(); + await t.wait(); + } catch (e) { + console.error(`Failed as expected`); + } + + // Working constructor + const Killable = await ethers.getContractFactory("Killable"); + const killable = await Killable.deploy(); + + console.error("Killable bytecode:", await Killable.getDeployTransaction()); + console.error(`Deployed Killable at `, await killable.getAddress()); + + // Self-destruct + const t = await killable.die(); + console.error(`Die tx: `, t); + + // Nested creation + const NestedCreation = await ethers.getContractFactory("NestedCreation"); + const nestedCreation = await NestedCreation.deploy(); + + console.error("NestedCreation bytecode:", await NestedCreation.getDeployTransaction()); + console.error(`Deployed nested creation at `, await nestedCreation.getAddress()); + // Nested creation with failure + const NestedCreationFail = await ethers.getContractFactory("NestedCreationFail"); + const nestedCreationFail = await NestedCreationFail.deploy(); + + console.error("NestedCreationFail bytecode:", await NestedCreationFail.getDeployTransaction()); + console.error(`Deployed nested creation fail at `, await nestedCreationFail.getAddress()); +})(); diff --git a/test/samples/local/contract_lifetime/txs/tx00.json b/test/samples/local/contract_lifetime/txs/tx00.json new file mode 100644 index 0000000..e562a82 --- /dev/null +++ b/test/samples/local/contract_lifetime/txs/tx00.json @@ -0,0 +1,220 @@ +{ + "initialState": { + "accounts": { + "0xAaaaAaAAaaaAAaAAaAaaaaAAAAAaAaaaAaAaaAA0": { + "nonce": 0, + "balance": "0x0000000000000000000000f000000000", + "code": "", + "storage": {} + }, + "0xAaAaaAAAaAaaAaAaAaaAAaAaAAAAAaAAAaaAaAa2": { + "nonce": 0, + "balance": "0x0000000000000000000000f000000000", + "code": "", + "storage": {} + }, + "0xafFEaFFEAFfeAfFEAffeaFfEAfFEaffeafFeAFfE": { + "nonce": 0, + "balance": "0x0000000000000000000000f000000000", + "code": "", + "storage": {} + } + } + }, + "steps": [ + { + "address": "0x0000000000000000000000000000000000000000", + "gasLimit": "0xff0000", + "gasPrice": "0x1", + "input": "0x6080604052348015600e575f80fd5b5f80fdfe", + "origin": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0", + "value": "0x0", + "blockCoinbase": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0", + "blockDifficulty": "0xc", + "blockGasLimit": "0xff0000", + "blockNumber": 1, + "blockTime": 1, + "result": { + "kind": "revert" + }, + "liveContracts": [] + }, + { + "address": "0x0000000000000000000000000000000000000000", + "gasLimit": "0xff0000", + "gasPrice": "0x1", + "input": "0x6080604052348015600e575f80fd5b5060818061001b5f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c806335f4699414602a575b5f80fd5b60306032565b005b5f73ffffffffffffffffffffffffffffffffffffffff16fffea2646970667358221220aac49067c690fc4a7a711ec18c9a8b6accf3004cea6deef0a7f51a029997a97e64736f6c63430008150033", + "origin": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0", + "value": "0x0", + "blockCoinbase": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0", + "blockDifficulty": "0xc", + "blockGasLimit": "0xff0000", + "blockNumber": 1, + "blockTime": 1, + "result": { + "kind": "contract_created", + "address": "0x1faca6f2f8e169c54e0b1fe6d889dfc21ab5737e" + }, + "liveContracts": [] + }, + { + "address": "0x1faca6f2f8e169c54e0b1fe6d889dfc21ab5737e", + "gasLimit": "0xff0000", + "gasPrice": "0x1", + "input": "0x35f46994", + "origin": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0", + "value": "0x0", + "blockCoinbase": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0", + "blockDifficulty": "0xc", + "blockGasLimit": "0xff0000", + "blockNumber": 2, + "blockTime": 2, + "result": { + "kind": "value_returned", + "value": "" + }, + "liveContracts": ["0x1faca6f2f8e169c54e0b1fe6d889dfc21ab5737e"] + }, + { + "address": "0x0000000000000000000000000000000000000000", + "gasLimit": "0xff0000", + "gasPrice": "0x1", + "input": "0x608060405234801561000f575f80fd5b5060405161001c90610079565b604051809103905ff080158015610035573d5f803e3d5ffd5b505f806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550610085565b609c8061011283390190565b6081806100915f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c806335f4699414602a575b5f80fd5b60306032565b005b5f73ffffffffffffffffffffffffffffffffffffffff16fffea264697066735822122022b5ad5f782b0bc41d4425d4f3537930800b64da0c6d3808b7c1cfc35533989364736f6c634300081500336080604052348015600e575f80fd5b5060818061001b5f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c806335f4699414602a575b5f80fd5b60306032565b005b5f73ffffffffffffffffffffffffffffffffffffffff16fffea2646970667358221220aac49067c690fc4a7a711ec18c9a8b6accf3004cea6deef0a7f51a029997a97e64736f6c63430008150033", + "origin": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0", + "value": "0x0", + "blockCoinbase": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0", + "blockDifficulty": "0xc", + "blockGasLimit": "0xff0000", + "blockNumber": 1, + "blockTime": 1, + "result": { + "kind": "contract_created", + "address": "0x66d9baa1e8afa844766e15103b3b2a533304af5b" + }, + "liveContracts": [] + }, + { + "address": "0x0000000000000000000000000000000000000000", + "gasLimit": "0xff0000", + "gasPrice": "0x1", + "input": "0x608060405234801561000f575f80fd5b5060405161001c90610064565b604051809103905ff0801561002e5760015b1561003557505b5f60405161004290610070565b604051809103905ff08015801561005b573d5f803e3d5ffd5b5090505061007c565b60138061010983390190565b609c8061011c83390190565b6081806100885f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c806335f4699414602a575b5f80fd5b60306032565b005b5f73ffffffffffffffffffffffffffffffffffffffff16fffea264697066735822122005e088379ce3c7f9582da2f32848f32e2a0e0351d10b82981d122e2f0ac9963664736f6c634300081500336080604052348015600e575f80fd5b5f80fdfe6080604052348015600e575f80fd5b5060818061001b5f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c806335f4699414602a575b5f80fd5b60306032565b005b5f73ffffffffffffffffffffffffffffffffffffffff16fffea2646970667358221220aac49067c690fc4a7a711ec18c9a8b6accf3004cea6deef0a7f51a029997a97e64736f6c63430008150033", + "origin": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0", + "value": "0x0", + "blockCoinbase": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0", + "blockDifficulty": "0xc", + "blockGasLimit": "0xff0000", + "blockNumber": 1, + "blockTime": 1, + "result": { + "kind": "contract_created", + "address": "0x8d57cb6b2c9889b43514e729b70c17d7afb8227c" + }, + "liveContracts": [ + "0x66d9baa1e8afa844766e15103b3b2a533304af5b", + "0x5706659cf82b70d4b805ba2e9540cbc1b60fec22" + ] + }, + { + "address": "0x8d57cb6b2c9889b43514e729b70c17d7afb8227c", + "gasLimit": "0xff0000", + "gasPrice": "0x1", + "input": "0x35f46994", + "origin": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0", + "value": "0x0", + "blockCoinbase": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0", + "blockDifficulty": "0xc", + "blockGasLimit": "0xff0000", + "blockNumber": 2, + "blockTime": 2, + "result": { + "kind": "value_returned", + "value": "" + }, + "liveContracts": [ + "0x5706659cf82b70d4b805ba2e9540cbc1b60fec22", + "0x66d9baa1e8afa844766e15103b3b2a533304af5b", + "0x8d57cb6b2c9889b43514e729b70c17d7afb8227c", + "0x99ef7cc5214b804f7ffba13c70a2d7c2f9763d60" + ] + }, + { + "address": "0x5706659cf82b70d4b805ba2e9540cbc1b60fec22", + "gasLimit": "0xff0000", + "gasPrice": "0x1", + "input": "0x35f46994", + "origin": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0", + "value": "0x0", + "blockCoinbase": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0", + "blockDifficulty": "0xc", + "blockGasLimit": "0xff0000", + "blockNumber": 2, + "blockTime": 2, + "result": { + "kind": "value_returned", + "value": "" + }, + "liveContracts": [ + "0x5706659cf82b70d4b805ba2e9540cbc1b60fec22", + "0x66d9baa1e8afa844766e15103b3b2a533304af5b", + "0x99ef7cc5214b804f7ffba13c70a2d7c2f9763d60" + ] + }, + { + "address": "0x66d9baa1e8afa844766e15103b3b2a533304af5b", + "gasLimit": "0xff0000", + "gasPrice": "0x1", + "input": "0x35f46994", + "origin": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0", + "value": "0x0", + "blockCoinbase": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0", + "blockDifficulty": "0xc", + "blockGasLimit": "0xff0000", + "blockNumber": 2, + "blockTime": 2, + "result": { + "kind": "value_returned", + "value": "" + }, + "liveContracts": [ + "0x66d9baa1e8afa844766e15103b3b2a533304af5b", + "0x99ef7cc5214b804f7ffba13c70a2d7c2f9763d60" + ] + }, + { + "address": "0x99ef7cc5214b804f7ffba13c70a2d7c2f9763d60", + "gasLimit": "0xff0000", + "gasPrice": "0x1", + "input": "0x35f46994", + "origin": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0", + "value": "0x0", + "blockCoinbase": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0", + "blockDifficulty": "0xc", + "blockGasLimit": "0xff0000", + "blockNumber": 2, + "blockTime": 2, + "result": { + "kind": "value_returned", + "value": "" + }, + "liveContracts": ["0x99ef7cc5214b804f7ffba13c70a2d7c2f9763d60"] + }, + { + "address": "0x99ef7cc5214b804f7ffba13c70a2d7c2f9763d60", + "gasLimit": "0xff0000", + "gasPrice": "0x1", + "input": "0x35f46994", + "origin": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0", + "value": "0x0", + "blockCoinbase": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0", + "blockDifficulty": "0xc", + "blockGasLimit": "0xff0000", + "blockNumber": 2, + "blockTime": 2, + "result": { + "kind": "value_returned", + "value": "" + }, + "liveContracts": [] + } + ] +}