Analysis Run

ba3ba713-4917-460e-9f7b-996b19f1fce4

complete

Chain ID

1

Address

0x91a48de48c9f80bd1d79f5c22c3051478001b09f

Block Number

—

Created

Mon, Dec 29, 2025 11:53 PM

Review Summary

What survived the funnel

Open this run to answer one question: is this real attacker-relevant behavior with real impact, or just normal contract plumbing?

back to vulns open contract

Confirmed

0

Validated

0

Source

Bytecode only

Review Backing

Not yet

Best current signal

ETH value transfer possible

crit 0 high 0 direct contract

Review Checklist

1. Read the findings table first. Ignore raw jobs until the result looks real.

2. Confirm attacker control, not just the existence of a sink.

3. Confirm money or privilege impact.

4. Keep it if the behavior is real. Kill it if this is normal proxy, admin, or upgrade plumbing.

Processing Jobs

Status & attempts

ID	Type	Status	Attempts	Heartbeat
30620	report.consolidate	complete	1 / 1	3 months ago
74716	artifact.fetch	complete	1 / 3	2 weeks ago
74717	tool.cast_disasm	complete	1 / 3	2 weeks ago
74718	analysis.bundle	complete	1 / 3	2 weeks ago
74719	capability.graph	complete	1 / 3	2 weeks ago
74720	detector.run	complete	1 / 3	2 weeks ago
74721	validation.fork	complete	1 / 3	2 weeks ago

Artifact

Runtime bytecode: available

Creation TX: —

Deployer: —

Proxy: no

Implementation:

—

Verified Source: no

Slither

tool.slither

No slither job recorded yet.

Codex

report.consolidate

Job Status

complete

Attempts

1 / 1

Findings

0

No findings?

yes

Summary

Reviewed runtime bytecode for concrete vulnerability patterns (AccessControl, ReentrancyGuard, SafeERC20-style calls observed); no actionable issues could be confirmed from bytecode/disasm alone.

View stderr

[codex:1499054] OpenAI Codex v0.77.0 (research preview)
[codex:1499054] --------
[codex:1499054] workdir: /tmp/codex-multi-fq9ccdne
[codex:1499054] model: gpt-5.2-codex
[codex:1499054] provider: openai
[codex:1499054] approval: never
[codex:1499054] sandbox: read-only
[codex:1499054] reasoning effort: xhigh
[codex:1499054] reasoning summaries: auto
[codex:1499054] session id: 019b6c7b-9030-7451-98d2-cd9d26072476
[codex:1499054] --------
[codex:1499054] user
[codex:1499054] You are a security auditor. You are given EVM runtime bytecode (and possibly a disassembly) for a contract with NO verified source.
[codex:1499054] This is best-effort. Do not hallucinate: only flag issues when there's a concrete, explainable angle from bytecode/disasm patterns.
[codex:1499054] 
[codex:1499054] You MUST read the full `BYTECODE_BUNDLE.txt` before concluding.
[codex:1499054] 
[codex:1499054] Output MUST be valid JSON matching the provided schema.
[codex:1499054] - If you cannot identify a concrete issue from bytecode/disasm alone: set no_findings=true and findings=[].
[codex:1499054] - Otherwise: include findings with severity/category/title/evidence and point locations to BYTECODE_BUNDLE.txt line ranges when possible.
[codex:1499054] 
[codex:1499054] Output constraints (IMPORTANT):
[codex:1499054] - severity MUST be exactly one of: info, low, medium, high, critical (lowercase).
[codex:1499054] - category MUST be exactly one of: access_control, reentrancy, math, oracle, upgradeability, auth, other.
[codex:1499054] mcp startup: no servers
[codex:1499054] 
[codex:1499054] thinking
[codex:1499054] **Reading BYTECODE_BUNDLE.txt file**
[codex:1499054] exec
[codex:1499054] /bin/bash -lc ls in /tmp/codex-multi-fq9ccdne succeeded in 5ms:
[codex:1499054] BYTECODE_BUNDLE.txt
[codex:1499054] codex-output-schema.json
[codex:1499054] exec
[codex:1499054] /bin/bash -lc 'cat BYTECODE_BUNDLE.txt' in /tmp/codex-multi-fq9ccdne succeeded in 5ms:
[codex:1499054] Runtime bytecode bundle for best-effort auditing.
[codex:1499054] Note: without verified source, conclusions are low-confidence unless a concrete pattern is visible.
[codex:1499054] 
[codex:1499054] FILE: runtime_bytecode.hex
[codex:1499054] 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
[codex:1499054] 
[codex:1499054] thinking
[codex:1499054] **Preparing to output JSON schema**
[codex:1499054] exec
[codex:1499054] /bin/bash -lc 'cat codex-output-schema.json' in /tmp/codex-multi-fq9ccdne succeeded in 5ms:
[codex:1499054] {"type": "object", "additionalProperties": false, "required": ["no_findings", "summary", "findings"], "properties": {"no_findings": {"type": "boolean"}, "summary": {"type": "string"}, "findings": {"type": "array", "items": {"type": "object", "additionalProperties": false, "required": ["severity", "category", "title", "evidence", "locations", "exploit_scenario", "recommendation"], "properties": {"severity": {"type": "string", "enum": ["info", "low", "medium", "high", "critical"]}, "category": {"type": "string", "enum": ["access_control", "reentrancy", "math", "oracle", "upgradeability", "auth", "other"]}, "title": {"type": "string"}, "exploit_scenario": {"type": "string"}, "recommendation": {"type": "string"}, "evidence": {"type": "string"}, "locations": {"type": "array", "items": {"type": "string"}}}}}}}
[codex:1499054] 
[codex:1499054] thinking
[codex:1499054] **Analyzing bytecode for risks**
[codex:1499054] 
[codex:1499054] I'm examining this Bank-like contract bytecode, spotting ERC20 patterns and SafeERC20 usage, owner and pausable logic, and external token calls. I'll focus on potential reentrancy, access control, and initialization gaps using function selectors and revert strings to pinpoint vulnerabilities with bytecode evidence.
[codex:1499054] exec
[codex:1499054] /bin/bash -lc 'nl -ba BYTECODE_BUNDLE.txt' in /tmp/codex-multi-fq9ccdne succeeded in 6ms:
[codex:1499054]      1	Runtime bytecode bundle for best-effort auditing.
[codex:1499054]      2	Note: without verified source, conclusions are low-confidence unless a concrete pattern is visible.
[codex:1499054]      3	
[codex:1499054]      4	FILE: runtime_bytecode.hex
[codex:1499054]      5	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
[codex:1499054] 
[codex:1499054] 
[codex:1499054] thinking
[codex:1499054] **Analyzing contract bytecode and roles**
[codex:1499054] 
[codex:1499054] I'm piecing together the contract's structure from bytecode, identifying it uses AccessControl roles, ERC1155-style approvals, and likely token deposit/withdraw logic. I’m mapping function selectors to roles and access checks to understand any security gaps or missing restrictions. This step-by-step decoding reveals the contract’s role-based permission setup and complex role management functions.
[codex:1499054] thinking
[codex:1499054] **Inspecting internal role and guard functions**
[codex:1499054] 
[codex:1499054] I’m examining bytecode around key offsets to identify internal functions like role checks, pause logic, and reentrancy guard usage. This helps me confirm how these mechanisms operate and interact within the contract’s flow, focusing on `_checkRole` and slot manipulations indicating guard status.
[codex:1499054] exec
[codex:1499054] /bin/bash -lc 'rg -o "60015f54" BYTECODE_BUNDLE.txt' in /tmp/codex-multi-fq9ccdne exited 1 in 9ms:
[codex:1499054] 
[codex:1499054] 
[codex:1499054] thinking
[codex:1499054] **Searching for pattern "60015f55"**
[codex:1499054] exec
[codex:1499054] /bin/bash -lc 'rg -o "60015f55" BYTECODE_BUNDLE.txt' in /tmp/codex-multi-fq9ccdne succeeded in 6ms:
[codex:1499054] 60015f55
[codex:1499054] 60015f55
[codex:1499054] 
[codex:1499054] thinking
[codex:1499054] **Investigating reentrancy guard usage**
[codex:1499054] exec
[codex:1499054] /bin/bash -lc 'rg -o "60025f54" BYTECODE_BUNDLE.txt' in /tmp/codex-multi-fq9ccdne succeeded in 6ms:
[codex:1499054] 60025f54
[codex:1499054] 
[codex:1499054] thinking
[codex:1499054] **Analyzing bytecode for role and pause checks**
[codex:1499054] exec
[codex:1499054] /bin/bash -lc "python - <<'PY'
[codex:1499054] import re, sys
[codex:1499054] hexstr=open('BYTECODE_BUNDLE.txt').read()
[codex:1499054] # extract hex after 0x
[codex:1499054] m=re.search(r'0x([0-9a-fA-F]+)', hexstr)
[codex:1499054] if not m:
[codex:1499054]     print('no hex')
[codex:1499054]     sys.exit(1)
[codex:1499054] code=bytes.fromhex(m.group(1))
[codex:1499054] # opcode map
[codex:1499054] opmap={
[codex:1499054]     0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',
[codex:1499054]     0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',
[codex:1499054]     0x20:'SHA3',
[codex:1499054]     0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',
[codex:1499054]     0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',
[codex:1499054]     0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',
[codex:1499054]     0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',
[codex:1499054]     0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'
[codex:1499054] }
[codex:1499054] for i in range(1,33):
[codex:1499054]     opmap[0x5f+i]=f'PUSH{i}'
[codex:1499054] for i in range(1,17):
[codex:1499054]     opmap[0x7f+i]=f'DUP{i}'
[codex:1499054] for i in range(1,17):
[codex:1499054]     opmap[0x8f+i]=f'SWAP{i}'
[codex:1499054] 
[codex:1499054] # disassemble around certain offsets
[codex:1499054] # We'll output all with offsets for easier search
[codex:1499054] out=[]
[codex:1499054] off=0
[codex:1499054] while off < len(code):
[codex:1499054]     op=code[off]
[codex:1499054]     name=opmap.get(op, f'OP{op:02x}')
[codex:1499054]     off0=off
[codex:1499054]     off+=1
[codex:1499054]     arg=b''
[codex:1499054]     if name.startswith('PUSH'):
[codex:1499054]         n=int(name[4:])
[codex:1499054]         arg=code[off:off+n]
[codex:1499054]         off+=n
[codex:1499054]         out.append(f'{off0:04x}: {name} 0x{arg.hex()}')
[codex:1499054]     else:
[codex:1499054]         out.append(f'{off0:04x}: {name}')
[codex:1499054] # print total len
[codex:1499054] print('len', len(code))
[codex:1499054] # print snippet around 0x04db
[codex:1499054] start=0x04a0
[codex:1499054] end=0x0520
[codex:1499054] for line in out:
[codex:1499054]     addr=int(line.split(':')[0],16)
[codex:1499054]     if start<=addr<=end:
[codex:1499054]         print(line)
[codex:1499054] PY" in /tmp/codex-multi-fq9ccdne succeeded in 45ms:
[codex:1499054] len 2199
[codex:1499054] 04a1: PUSH1 0xa0
[codex:1499054] 04a3: SHL
[codex:1499054] 04a4: SUB
[codex:1499054] 04a5: SWAP4
[codex:1499054] 04a6: SWAP1
[codex:1499054] 04a7: SWAP4
[codex:1499054] 04a8: AND
[codex:1499054] 04a9: DUP5
[codex:1499054] 04aa: MSTORE
[codex:1499054] 04ab: SWAP2
[codex:1499054] 04ac: SWAP1
[codex:1499054] 04ad: MSTORE
[codex:1499054] 04ae: SWAP1
[codex:1499054] 04af: SHA3
[codex:1499054] 04b0: SLOAD
[codex:1499054] 04b1: PUSH1 0xff
[codex:1499054] 04b3: AND
[codex:1499054] 04b4: SWAP1
[codex:1499054] 04b5: JUMP
[codex:1499054] 
[codex:1499054] thinking
[codex:1499054] **Analyzing reentrancy guard implementation**
[codex:1499054] exec
[codex:1499054] /bin/bash -lc "python - <<'PY'
[codex:1499054] import re
[codex:1499054] hexstr=open('BYTECODE_BUNDLE.txt').read();
[codex:1499054] import re
[codex:1499054] m=re.search(r'0x([0-9a-fA-F]+)', hexstr)
[codex:1499054] code=bytes.fromhex(m.group(1))
[codex:1499054] opmap={0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',0x20:'SHA3',0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'}
[codex:1499054] for i in range(1,33): opmap[0x5f+i]=f'PUSH{i}'
[codex:1499054] for i in range(1,17): opmap[0x7f+i]=f'DUP{i}'
[codex:1499054] for i in range(1,17): opmap[0x8f+i]=f'SWAP{i}'
[codex:1499054] 
[codex:1499054] # disassemble around 0x0670-0x06b0
[codex:1499054] out=[];off=0
[codex:1499054] while off<len(code):
[codex:1499054]     op=code[off];name=opmap.get(op,f'OP{op:02x}');off0=off;off+=1
[codex:1499054]     if name.startswith('PUSH'):
[codex:1499054]         n=int(name[4:]);arg=code[off:off+n];off+=n;out.append(f'{off0:04x}: {name} 0x{arg.hex()}')
[codex:1499054]     else: out.append(f'{off0:04x}: {name}')
[codex:1499054] 
[codex:1499054] for line in out:
[codex:1499054]     addr=int(line.split(':')[0],16)
[codex:1499054]     if 0x0660<=addr<=0x06b0:
[codex:1499054]         print(line)
[codex:1499054] PY" in /tmp/codex-multi-fq9ccdne succeeded in 31ms:
[codex:1499054] 0660: PUSH1 0xa0
[codex:1499054] 0662: SHL
[codex:1499054] 0663: SUB
[codex:1499054] 0664: DUP4
[codex:1499054] 0665: DUP2
[codex:1499054] 0666: AND
[codex:1499054] 0667: PUSH1 0x24
[codex:1499054] 0669: DUP4
[codex:1499054] 066a: ADD
[codex:1499054] 066b: MSTORE
[codex:1499054] 066c: PUSH1 0x44
[codex:1499054] 066e: DUP3
[codex:1499054] 066f: ADD
[codex:1499054] 0670: DUP4
[codex:1499054] 0671: SWAP1
[codex:1499054] 0672: MSTORE
[codex:1499054] 0673: PUSH2 0x0308
[codex:1499054] 0676: SWAP2
[codex:1499054] 0677: DUP6
[codex:1499054] 0678: SWAP2
[codex:1499054] 
[codex:1499054] thinking
[codex:1499054] **Mapping function roles and reentrancy**
[codex:1499054] exec
[codex:1499054] /bin/bash -lc "python - <<'PY'
[codex:1499054] import re
[codex:1499054] hexstr=open('BYTECODE_BUNDLE.txt').read();
[codex:1499054] m=re.search(r'0x([0-9a-fA-F]+)', hexstr)
[codex:1499054] code=bytes.fromhex(m.group(1))
[codex:1499054] opmap={0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',0x20:'SHA3',0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'}
[codex:1499054] for i in range(1,33): opmap[0x5f+i]=f'PUSH{i}'
[codex:1499054] for i in range(1,17): opmap[0x7f+i]=f'DUP{i}'
[codex:1499054] for i in range(1,17): opmap[0x8f+i]=f'SWAP{i}'
[codex:1499054] 
[codex:1499054] # Build disassembly list with offsets
[codex:1499054] out=[];off=0
[codex:1499054] while off<len(code):
[codex:1499054]     op=code[off];name=opmap.get(op,f'OP{op:02x}');off0=off;off+=1
[codex:1499054]     if name.startswith('PUSH'):
[codex:1499054]         n=int(name[4:]);arg=code[off:off+n];off+=n;out.append((off0,f'{name} 0x{arg.hex()}'))
[codex:1499054]     else: out.append((off0,name))
[codex:1499054] 
[codex:1499054] # function starts
[codex:1499054] starts=[0x009f,0x00c7,0x00dc,0x010d,0x0120,0x0133,0x0146,0x0159,0x0160,0x0173]
[codex:1499054] for s in starts:
[codex:1499054]     print('\\n=== start',hex(s),'===')
[codex:1499054]     for off,name in out:
[codex:1499054]         if s<=off< s+0x50:
[codex:1499054]             print(f'{off:04x}: {name}')
[codex:1499054] PY" in /tmp/codex-multi-fq9ccdne succeeded in 41ms:
[codex:1499054] 
[codex:1499054] === start 0x9f ===
[codex:1499054] 009f: JUMPDEST
[codex:1499054] 00a0: PUSH2 0x00b2
[codex:1499054] 00a3: PUSH2 0x00ad
[codex:1499054] 00a6: CALLDATASIZE
[codex:1499054] 00a7: PUSH1 0x04
[codex:1499054] 00a9: PUSH2 0x0732
[codex:1499054] 00ac: JUMP
[codex:1499054] 00ad: JUMPDEST
[codex:1499054] 00ae: PUSH2 0x019a
[codex:1499054] 00b1: JUMP
[codex:1499054] 00b2: JUMPDEST
[codex:1499054] 00b3: PUSH1 0x40
[codex:1499054] 00b5: MLOAD
[codex:1499054] 00b6: SWAP1
[codex:1499054] 00b7: ISZERO
[codex:1499054] 00b8: ISZERO
[codex:1499054] 00b9: DUP2
[codex:1499054] 00ba: MSTORE
[codex:1499054] 
[codex:1499054] thinking
[codex:1499054] **Analyzing function selectors and constants**
[codex:1499054] exec
[codex:1499054] /bin/bash -lc "python - <<'PY'
[codex:1499054] import re
[codex:1499054] hexstr=open('BYTECODE_BUNDLE.txt').read();
[codex:1499054] m=re.search(r'0x([0-9a-fA-F]+)', hexstr)
[codex:1499054] code=bytes.fromhex(m.group(1))
[codex:1499054] opmap={0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',0x20:'SHA3',0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'}
[codex:1499054] for i in range(1,33): opmap[0x5f+i]=f'PUSH{i}'
[codex:1499054] for i in range(1,17): opmap[0x7f+i]=f'DUP{i}'
[codex:1499054] for i in range(1,17): opmap[0x8f+i]=f'SWAP{i}'
[codex:1499054] 
[codex:1499054] # disassemble around 0x036b
[codex:1499054] out=[];off=0
[codex:1499054] while off<len(code):
[codex:1499054]     op=code[off];name=opmap.get(op,f'OP{op:02x}');off0=off;off+=1
[codex:1499054]     if name.startswith('PUSH'):
[codex:1499054]         n=int(name[4:]);arg=code[off:off+n];off+=n;out.append((off0,f'{name} 0x{arg.hex()}'))
[codex:1499054]     else: out.append((off0,name))
[codex:1499054] 
[codex:1499054] for off,name in out:
[codex:1499054]     if 0x0350<=off<=0x0410:
[codex:1499054]         print(f'{off:04x}: {name}')
[codex:1499054] PY" in /tmp/codex-multi-fq9ccdne succeeded in 27ms:
[codex:1499054] 0351: PUSH1 0xe1
[codex:1499054] 0353: SHL
[codex:1499054] 0354: DUP2
[codex:1499054] 0355: MSTORE
[codex:1499054] 0356: PUSH1 0x04
[codex:1499054] 0358: ADD
[codex:1499054] 0359: PUSH1 0x40
[codex:1499054] 035b: MLOAD
[codex:1499054] 035c: DUP1
[codex:1499054] 035d: SWAP2
[codex:1499054] 035e: SUB
[codex:1499054] 035f: SWAP1
[codex:1499054] 0360: REVERT
[codex:1499054] 0361: JUMPDEST
[codex:1499054] 0362: PUSH2 0x0308
[codex:1499054] 0365: DUP3
[codex:1499054] 0366: DUP3
[codex:1499054] 0367: PUSH2 0x05ed
[codex:1499054] 036a: JUMP
[codex:1499054] 036b: JUMPDEST
[codex:1499054] 
[codex:1499054] thinking
[codex:1499054] **Continuing process**
[codex:1499054] exec
[codex:1499054] /bin/bash -lc "python - <<'PY'
[codex:1499054] import re
[codex:1499054] hexstr=open('BYTECODE_BUNDLE.txt').read();
[codex:1499054] m=re.search(r'0x([0-9a-fA-F]+)', hexstr)
[codex:1499054] code=bytes.fromhex(m.group(1))
[codex:1499054] opmap={0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',0x20:'SHA3',0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'}
[codex:1499054] for i in range(1,33): opmap[0x5f+i]=f'PUSH{i}'
[codex:1499054] for i in range(1,17): opmap[0x7f+i]=f'DUP{i}'
[codex:1499054] for i in range(1,17): opmap[0x8f+i]=f'SWAP{i}'
[codex:1499054] 
[codex:1499054] out=[];off=0
[codex:1499054] while off<len(code):
[codex:1499054]     op=code[off];name=opmap.get(op,f'OP{op:02x}');off0=off;off+=1
[codex:1499054]     if name.startswith('PUSH'):
[codex:1499054]         n=int(name[4:]);arg=code[off:off+n];off+=n;out.append((off0,f'{name} 0x{arg.hex()}'))
[codex:1499054]     else: out.append((off0,name))
[codex:1499054] 
[codex:1499054] for off,name in out:
[codex:1499054]     if 0x0400<=off<=0x04a0:
[codex:1499054]         print(f'{off:04x}: {name}')
[codex:1499054] PY" in /tmp/codex-multi-fq9ccdne succeeded in 28ms:
[codex:1499054] 0401: JUMP
[codex:1499054] 0402: JUMPDEST
[codex:1499054] 0403: OP5f
[codex:1499054] 0404: DUP3
[codex:1499054] 0405: GT
[codex:1499054] 0406: PUSH2 0x0421
[codex:1499054] 0409: JUMPI
[codex:1499054] 040a: PUSH1 0x40
[codex:1499054] 040c: MLOAD
[codex:1499054] 040d: PUSH3 0x461bcd
[codex:1499054] 0411: PUSH1 0xe5
[codex:1499054] 0413: SHL
[codex:1499054] 0414: DUP2
[codex:1499054] 0415: MSTORE
[codex:1499054] 0416: PUSH1 0x04
[codex:1499054] 0418: ADD
[codex:1499054] 0419: PUSH2 0x0221
[codex:1499054] 041c: SWAP1
[codex:1499054] 041d: PUSH2 0x07f7
[codex:1499054] 0420: JUMP
[codex:1499054] 
[codex:1499054] thinking
[codex:1499054] **Analyzing function with reentrancy guard**
[codex:1499054] exec
[codex:1499054] /bin/bash -lc "python - <<'PY'
[codex:1499054] import re
[codex:1499054] hexstr=open('BYTECODE_BUNDLE.txt').read();
[codex:1499054] m=re.search(r'0x([0-9a-fA-F]+)', hexstr)
[codex:1499054] code=bytes.fromhex(m.group(1))
[codex:1499054] opmap={0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',0x20:'SHA3',0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'}
[codex:1499054] for i in range(1,33): opmap[0x5f+i]=f'PUSH{i}'
[codex:1499054] for i in range(1,17): opmap[0x7f+i]=f'DUP{i}'
[codex:1499054] for i in range(1,17): opmap[0x8f+i]=f'SWAP{i}'
[codex:1499054] 
[codex:1499054] out=[];off=0
[codex:1499054] while off<len(code):
[codex:1499054]     op=code[off];name=opmap.get(op,f'OP{op:02x}');off0=off;off+=1
[codex:1499054]     if name.startswith('PUSH'):
[codex:1499054]         n=int(name[4:]);arg=code[off:off+n];off+=n;out.append((off0,f'{name} 0x{arg.hex()}'))
[codex:1499054]     else: out.append((off0,name))
[codex:1499054] 
[codex:1499054] for off,name in out:
[codex:1499054]     if 0x01d0<=off<=0x0310:
[codex:1499054]         print(f'{off:04x}: {name}')
[codex:1499054] PY" in /tmp/codex-multi-fq9ccdne succeeded in 28ms:
[codex:1499054] 01d0: JUMPDEST
[codex:1499054] 01d1: PUSH2 0x01d8
[codex:1499054] 01d4: PUSH2 0x04db
[codex:1499054] 01d7: JUMP
[codex:1499054] 01d8: JUMPDEST
[codex:1499054] 01d9: PUSH32 0xc2949446873dcc27a43f979db2c832ea16ea1440ad63667d35ce8013841bb24b
[codex:1499054] 01fa: PUSH2 0x0202
[codex:1499054] 01fd: DUP2
[codex:1499054] 01fe: PUSH2 0x0503
[codex:1499054] 0201: JUMP
[codex:1499054] 0202: JUMPDEST
[codex:1499054] 0203: OP5f
[codex:1499054] 0204: DUP3
[codex:1499054] 0205: GT
[codex:1499054] 0206: PUSH2 0x022a
[codex:1499054] 0209: JUMPI
[codex:1499054] 020a: PUSH1 0x40
[codex:1499054] 020c: MLOAD
[codex:1499054] 020d: PUSH3 0x461bcd
[codex:1499054] 0211: PUSH1 0xe5
[codex:1499054] 
[codex:1499054] thinking
[codex:1499054] **Analyzing function parameters and role checks**
[codex:1499054] exec
[codex:1499054] /bin/bash -lc "python - <<'PY'
[codex:1499054] import re
[codex:1499054] hexstr=open('BYTECODE_BUNDLE.txt').read();
[codex:1499054] m=re.search(r'0x([0-9a-fA-F]+)', hexstr)
[codex:1499054] code=bytes.fromhex(m.group(1))
[codex:1499054] opmap={0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',0x20:'SHA3',0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'}
[codex:1499054] for i in range(1,33): opmap[0x5f+i]=f'PUSH{i}'
[codex:1499054] for i in range(1,17): opmap[0x7f+i]=f'DUP{i}'
[codex:1499054] for i in range(1,17): opmap[0x8f+i]=f'SWAP{i}'
[codex:1499054] 
[codex:1499054] out=[];off=0
[codex:1499054] while off<len(code):
[codex:1499054]     op=code[off];name=opmap.get(op,f'OP{op:02x}');off0=off;off+=1
[codex:1499054]     if name.startswith('PUSH'):
[codex:1499054]         n=int(name[4:]);arg=code[off:off+n];off+=n;out.append((off0,f'{name} 0x{arg.hex()}'))
[codex:1499054]     else: out.append((off0,name))
[codex:1499054] 
[codex:1499054] for off,name in out:
[codex:1499054]     if 0x0510<=off<=0x05c0:
[codex:1499054]         print(f'{off:04x}: {name}')
[codex:1499054] PY" in /tmp/codex-multi-fq9ccdne succeeded in 25ms:
[codex:1499054] 0510: JUMPDEST
[codex:1499054] 0511: PUSH1 0x40
[codex:1499054] 0513: MLOAD
[codex:1499054] 0514: PUSH1 0x01
[codex:1499054] 0516: PUSH1 0x01
[codex:1499054] 0518: PUSH1 0xa0
[codex:1499054] 051a: SHL
[codex:1499054] 051b: SUB
[codex:1499054] 051c: DUP5
[codex:1499054] 051d: DUP2
[codex:1499054] 051e: AND
[codex:1499054] 051f: PUSH1 0x24
[codex:1499054] 0521: DUP4
[codex:1499054] 0522: ADD
[codex:1499054] 0523: MSTORE
[codex:1499054] 0524: DUP4
[codex:1499054] 0525: DUP2
[codex:1499054] 0526: AND
[codex:1499054] 0527: PUSH1 0x44
[codex:1499054] 0529: DUP4
[codex:1499054] 
[codex:1499054] thinking
[codex:1499054] **Analyzing safeERC20 transferFrom call**
[codex:1499054] exec
[codex:1499054] /bin/bash -lc "python - <<'PY'
[codex:1499054] import re
[codex:1499054] hexstr=open('BYTECODE_BUNDLE.txt').read();
[codex:1499054] m=re.search(r'0x([0-9a-fA-F]+)', hexstr)
[codex:1499054] code=bytes.fromhex(m.group(1))
[codex:1499054] opmap={0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',0x20:'SHA3',0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'}
[codex:1499054] for i in range(1,33): opmap[0x5f+i]=f'PUSH{i}'
[codex:1499054] for i in range(1,17): opmap[0x7f+i]=f'DUP{i}'
[codex:1499054] for i in range(1,17): opmap[0x8f+i]=f'SWAP{i}'
[codex:1499054] 
[codex:1499054] out=[];off=0
[codex:1499054] while off<len(code):
[codex:1499054]     op=code[off];name=opmap.get(op,f'OP{op:02x}');off0=off;off+=1
[codex:1499054]     if name.startswith('PUSH'):
[codex:1499054]         n=int(name[4:]);arg=code[off:off+n];off+=n;out.append((off0,f'{name} 0x{arg.hex()}'))
[codex:1499054]     else: out.append((off0,name))
[codex:1499054] 
[codex:1499054] for off,name in out:
[codex:1499054]     if 0x0720<=off<=0x0790:
[codex:1499054]         print(f'{off:04x}: {name}')
[codex:1499054] PY" in /tmp/codex-multi-fq9ccdne succeeded in 25ms:
[codex:1499054] 0720: PUSH1 0xa0
[codex:1499054] 0722: SHL
[codex:1499054] 0723: SUB
[codex:1499054] 0724: DUP6
[codex:1499054] 0725: AND
[codex:1499054] 0726: PUSH1 0x04
[codex:1499054] 0728: DUP3
[codex:1499054] 0729: ADD
[codex:1499054] 072a: MSTORE
[codex:1499054] 072b: PUSH1 0x24
[codex:1499054] 072d: ADD
[codex:1499054] 072e: PUSH2 0x0221
[codex:1499054] 0731: JUMP
[codex:1499054] 0732: JUMPDEST
[codex:1499054] 0733: OP5f
[codex:1499054] 0734: PUSH1 0x20
[codex:1499054] 0736: DUP3
[codex:1499054] 0737: DUP5
[codex:1499054] 0738: SUB
[codex:1499054] 0739: SLT
[codex:1499054] 
[codex:1499054] thinking
[codex:1499054] **Analyzing function argument decoders**
[codex:1499054] exec
[codex:1499054] /bin/bash -lc "python - <<'PY'
[codex:1499054] import re
[codex:1499054] hexstr=open('BYTECODE_BUNDLE.txt').read();
[codex:1499054] m=re.search(r'0x([0-9a-fA-F]+)', hexstr)
[codex:1499054] code=bytes.fromhex(m.group(1))
[codex:1499054] opmap={0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',0x20:'SHA3',0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'}
[codex:1499054] for i in range(1,33): opmap[0x5f+i]=f'PUSH{i}'
[codex:1499054] for i in range(1,17): opmap[0x7f+i]=f'DUP{i}'
[codex:1499054] for i in range(1,17): opmap[0x8f+i]=f'SWAP{i}'
[codex:1499054] 
[codex:1499054] out=[];off=0
[codex:1499054] while off<len(code):
[codex:1499054]     op=code[off];name=opmap.get(op,f'OP{op:02x}');off0=off;off+=1
[codex:1499054]     if name.startswith('PUSH'):
[codex:1499054]         n=int(name[4:]);arg=code[off:off+n];off+=n;out.append((off0,f'{name} 0x{arg.hex()}'))
[codex:1499054]     else: out.append((off0,name))
[codex:1499054] 
[codex:1499054] for off,name in out:
[codex:1499054]     if 0x0774<=off<=0x07c0:
[codex:1499054]         print(f'{off:04x}: {name}')
[codex:1499054] PY" in /tmp/codex-multi-fq9ccdne succeeded in 28ms:
[codex:1499054] 0774: JUMPDEST
[codex:1499054] 0775: OP5f
[codex:1499054] 0776: DUP1
[codex:1499054] 0777: OP5f
[codex:1499054] 0778: PUSH1 0x60
[codex:1499054] 077a: DUP5
[codex:1499054] 077b: DUP7
[codex:1499054] 077c: SUB
[codex:1499054] 077d: SLT
[codex:1499054] 077e: ISZERO
[codex:1499054] 077f: PUSH2 0x0786
[codex:1499054] 0782: JUMPI
[codex:1499054] 0783: OP5f
[codex:1499054] 0784: DUP1
[codex:1499054] 0785: REVERT
[codex:1499054] 0786: JUMPDEST
[codex:1499054] 0787: DUP4
[codex:1499054] 0788: CALLDATALOAD
[codex:1499054] 0789: PUSH2 0x0791
[codex:1499054] 078c: DUP2
[codex:1499054] 
[codex:1499054] thinking
[codex:1499054] **Analyzing function argument decoding and roles**
[codex:1499054] exec
[codex:1499054] /bin/bash -lc "python - <<'PY'
[codex:1499054] import re
[codex:1499054] hexstr=open('BYTECODE_BUNDLE.txt').read();
[codex:1499054] m=re.search(r'0x([0-9a-fA-F]+)', hexstr)
[codex:1499054] code=bytes.fromhex(m.group(1))
[codex:1499054] opmap={0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',0x20:'SHA3',0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'}
[codex:1499054] for i in range(1,33): opmap[0x5f+i]=f'PUSH{i}'
[codex:1499054] for i in range(1,17): opmap[0x7f+i]=f'DUP{i}'
[codex:1499054] for i in range(1,17): opmap[0x8f+i]=f'SWAP{i}'
[codex:1499054] 
[codex:1499054] out=[];off=0
[codex:1499054] while off<len(code):
[codex:1499054]     op=code[off];name=opmap.get(op,f'OP{op:02x}');off0=off;off+=1
[codex:1499054]     if name.startswith('PUSH'):
[codex:1499054]         n=int(name[4:]);arg=code[off:off+n];off+=n;out.append((off0,f'{name} 0x{arg.hex()}'))
[codex:1499054]     else: out.append((off0,name))
[codex:1499054] 
[codex:1499054] for off,name in out:
[codex:1499054]     if 0x0640<=off<=0x0695:
[codex:1499054]         print(f'{off:04x}: {name}')
[codex:1499054] PY" in /tmp/codex-multi-fq9ccdne succeeded in 29ms:
[codex:1499054] 064e: SWAP2
[codex:1499054] 064f: SWAP1
[codex:1499054] 0650: LOG4
[codex:1499054] 0651: POP
[codex:1499054] 0652: PUSH1 0x01
[codex:1499054] 0654: PUSH2 0x01ca
[codex:1499054] 0657: JUMP
[codex:1499054] 0658: JUMPDEST
[codex:1499054] 0659: PUSH1 0x40
[codex:1499054] 065b: MLOAD
[codex:1499054] 065c: PUSH1 0x01
[codex:1499054] 065e: PUSH1 0x01
[codex:1499054] 0660: PUSH1 0xa0
[codex:1499054] 0662: SHL
[codex:1499054] 0663: SUB
[codex:1499054] 0664: DUP4
[codex:1499054] 0665: DUP2
[codex:1499054] 0666: AND
[codex:1499054] 0667: PUSH1 0x24
[codex:1499054] 0669: DUP4
[codex:1499054] 
[codex:1499054] 
[codex:1499054] thinking
[codex:1499054] **Analyzing deposit function parameter decoding**
[codex:1499054] thinking
[codex:1499054] **Investigating storage update and overflow check**
[codex:1499054] exec
[codex:1499054] /bin/bash -lc "python - <<'PY'
[codex:1499054] import re
[codex:1499054] hexstr=open('BYTECODE_BUNDLE.txt').read();
[codex:1499054] m=re.search(r'0x([0-9a-fA-F]+)', hexstr)
[codex:1499054] code=bytes.fromhex(m.group(1))
[codex:1499054] opmap={0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',0x20:'SHA3',0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'}
[codex:1499054] for i in range(1,33): opmap[0x5f+i]=f'PUSH{i}'
[codex:1499054] for i in range(1,17): opmap[0x7f+i]=f'DUP{i}'
[codex:1499054] for i in range(1,17): opmap[0x8f+i]=f'SWAP{i}'
[codex:1499054] 
[codex:1499054] out=[];off=0
[codex:1499054] while off<len(code):
[codex:1499054]     op=code[off];name=opmap.get(op,f'OP{op:02x}');off0=off;off+=1
[codex:1499054]     if name.startswith('PUSH'):
[codex:1499054]         n=int(name[4:]);arg=code[off:off+n];off+=n;out.append((off0,f'{name} 0x{arg.hex()}'))
[codex:1499054]     else: out.append((off0,name))
[codex:1499054] 
[codex:1499054] for off,name in out:
[codex:1499054]     if 0x0830<=off<=0x0865:
[codex:1499054]         print(f'{off:04x}: {name}')
[codex:1499054] PY" in /tmp/codex-multi-fq9ccdne succeeded in 38ms:
[codex:1499054] 0830: PUSH1 0xd0
[codex:1499054] 0832: SHL
[codex:1499054] 0833: PUSH1 0x60
[codex:1499054] 0835: DUP3
[codex:1499054] 0836: ADD
[codex:1499054] 0837: MSTORE
[codex:1499054] 0838: PUSH1 0x80
[codex:1499054] 083a: ADD
[codex:1499054] 083b: SWAP1
[codex:1499054] 083c: JUMP
[codex:1499054] 083d: JUMPDEST
[codex:1499054] 083e: OP5f
[codex:1499054] 083f: PUSH1 0x01
[codex:1499054] 0841: DUP3
[codex:1499054] 0842: ADD
[codex:1499054] 0843: PUSH2 0x085a
[codex:1499054] 0846: JUMPI
[codex:1499054] 0847: PUSH4 0x4e487b71
[codex:1499054] 084c: PUSH1 0xe0
[codex:1499054] 084e: SHL
[codex:1499054] 
[codex:1499054] thinking
[codex:1499054] **Analyzing bytecode addition routine**
[codex:1499054] exec
[codex:1499054] /bin/bash -lc 'rg -n "083d" BYTECODE_BUNDLE.txt' in /tmp/codex-multi-fq9ccdne succeeded in 7ms:
[codex:1499054] 5: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
[codex:1499054] 
[codex:1499054] thinking
[codex:1499054] **Analyzing function call and stack behavior**
[codex:1499054] exec
[codex:1499054] /bin/bash -lc "python - <<'PY'
[codex:1499054] # simulate 0x083d with symbolic stack
[codex:1499054] from collections import deque
[codex:1499054] 
[codex:1499054] def simulate(stack):
[codex:1499054]     # stack: list top first
[codex:1499054]     def pop():
[codex:1499054]         return stack.pop(0)
[codex:1499054]     def push(x):
[codex:1499054]         stack.insert(0,x)
[codex:1499054]     def dup(n):
[codex:1499054]         push(stack[n-1])
[codex:1499054]     def swap(n):
[codex:1499054]         stack[0], stack[n] = stack[n], stack[0]
[codex:1499054]     # ops
[codex:1499054]     # 083d: JUMPDEST (no-op)
[codex:1499054]     push(0) # PUSH0
[codex:1499054]     push(1) # PUSH1 1
[codex:1499054]     dup(3)  # DUP3
[codex:1499054]     # ADD
[codex:1499054]     a=pop(); b=pop(); push(f'({a}+{b})')
[codex:1499054]     # JUMPI to 0x085a if cond "'!=0 ; cond is top? Actually JUMPI pops dest and cond; dest is 0x085a (constant) pushed before JUMPI.
[codex:1499054]     # We push dest and check cond; for symbolic, assume cond !=0 so jump to 0x085a. This is the normal path.
[codex:1499054]     # So we need to model pushing dest before JUMPI.
[codex:1499054]     push('"'DEST_085a')
[codex:1499054]     # JUMPI: pops dest and cond
[codex:1499054]     dest=pop(); cond=pop()
[codex:1499054]     # assume cond "'!=0 -> jump; stack remains
[codex:1499054]     # At 0x085a: JUMPDEST
[codex:1499054]     # POP
[codex:1499054]     pop()
[codex:1499054]     push(1)
[codex:1499054]     # ADD
[codex:1499054]     a=pop(); b=pop(); push(f'"'({a}+{b})')
[codex:1499054]     # SWAP1
[codex:1499054]     swap(1)
[codex:1499054]     # JUMP (to address on top)
[codex:1499054]     # final stack
[codex:1499054]     return stack
[codex:1499054] 
[codex:1499054] # test with stack top-first [ret, x]
[codex:1499054] print('input [ret, x] ->', simulate(['ret','x']))
[codex:1499054] # test with [ret,x,y]
[codex:1499054] print('input [ret, x, y] ->', simulate(['ret','x','y']))
[codex:1499054] # test with [ret,x,y,z]
[codex:1499054] print('input [ret, x, y, z] ->', simulate(['ret','x','y','z']))
[codex:1499054] PY" in /tmp/codex-multi-fq9ccdne succeeded in 19ms:
[codex:1499054] input [ret, x] -> ['x', '(1+ret)']
[codex:1499054] input [ret, x, y] -> ['x', '(1+ret)', 'y']
[codex:1499054] input [ret, x, y, z] -> ['x', '(1+ret)', 'y', 'z']
[codex:1499054] 
[codex:1499054] thinking
[codex:1499054] **Analyzing precise stack behavior in simulation**
[codex:1499054] 
[codex:1499054] I’m untangling the EVM stack operations around DUP3, ADD, and JUMPI to understand which values are on the stack, ensuring we correctly simulate the stack order and condition evaluation, especially focusing on how the third item from the top ties into the overflow check before the conditional jump.
[codex:1499054] exec
[codex:1499054] /bin/bash -lc "python - <<'PY'
[codex:1499054] # simulate 0x083d precisely with symbolic values; top of stack is last element for convenience
[codex:1499054] 
[codex:1499054] def simulate(inputs):
[codex:1499054]     # inputs list bottom->top
[codex:1499054]     stack=inputs[:]
[codex:1499054]     def push(x): stack.append(x)
[codex:1499054]     def pop(): return stack.pop()
[codex:1499054]     def dup(n): stack.append(stack[-n])
[codex:1499054]     def swap(n): stack[-1], stack[-1-n] = stack[-1-n], stack[-1]
[codex:1499054]     # ops
[codex:1499054]     push('0')  # PUSH0
[codex:1499054]     push('1')  # PUSH1 1
[codex:1499054]     dup(3)     # DUP3 (third from top)
[codex:1499054]     # ADD
[codex:1499054]     a=pop(); b=pop(); push(f'({a}+{b})')
[codex:1499054]     # PUSH2 dest
[codex:1499054]     push('dest')
[codex:1499054]     # JUMPI pops dest and cond
[codex:1499054]     dest=pop(); cond=pop()
[codex:1499054]     # assume cond "'!=0 -> jump
[codex:1499054]     # JUMPDEST
[codex:1499054]     # POP
[codex:1499054]     pop()
[codex:1499054]     push('"'1')
[codex:1499054]     # ADD
[codex:1499054]     a=pop(); b=pop(); push(f'({a}+{b})')
[codex:1499054]     swap(1)
[codex:1499054]     # JUMP would pop dest? Actually JUMP uses top as dest, does not pop? It does pop. We'll stop before.
[codex:1499054]     return stack
[codex:1499054] 
[codex:1499054] for inp in [ ['ret','x','y'], ['ret','x','y','z'] ]:
[codex:1499054]     print('input',inp,'->',simulate(inp))
[codex:1499054] PY" in /tmp/codex-multi-fq9ccdne succeeded in 19ms:
[codex:1499054] input ['ret', 'x', 'y'] -> ['ret', '(1+y)', 'x']
[codex:1499054] input ['ret', 'x', 'y', 'z'] -> ['ret', 'x', '(1+z)', 'y']
[codex:1499054] 
[codex:1499054] thinking
[codex:1499054] **Analyzing stack manipulation and call parameters**
[codex:1499054] exec
[codex:1499054] /bin/bash -lc "python - <<'PY'
[codex:1499054] import re
[codex:1499054] hexstr=open('BYTECODE_BUNDLE.txt').read();
[codex:1499054] m=re.search(r'0x([0-9a-fA-F]+)', hexstr)
[codex:1499054] code=bytes.fromhex(m.group(1))
[codex:1499054] opmap={0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',0x20:'SHA3',0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'}
[codex:1499054] for i in range(1,33): opmap[0x5f+i]=f'PUSH{i}'
[codex:1499054] for i in range(1,17): opmap[0x7f+i]=f'DUP{i}'
[codex:1499054] for i in range(1,17): opmap[0x8f+i]=f'SWAP{i}'
[codex:1499054] 
[codex:1499054] out=[];off=0
[codex:1499054] while off<len(code):
[codex:1499054]     op=code[off];name=opmap.get(op,f'OP{op:02x}');off0=off;off+=1
[codex:1499054]     if name.startswith('PUSH'):
[codex:1499054]         n=int(name[4:]);arg=code[off:off+n];off+=n;out.append((off0,f'{name} 0x{arg.hex()}'))
[codex:1499054]     else: out.append((off0,name))
[codex:1499054] 
[codex:1499054] for off,name in out:
[codex:1499054]     if 0x06c0<=off<=0x0715:
[codex:1499054]         print(f'{off:04x}: {name}')
[codex:1499054] PY" in /tmp/codex-multi-fq9ccdne succeeded in 27ms:
[codex:1499054] 06c1: JUMP
[codex:1499054] 06c2: JUMPDEST
[codex:1499054] 06c3: POP
[codex:1499054] 06c4: POP
[codex:1499054] 06c5: JUMP
[codex:1499054] 06c6: JUMPDEST
[codex:1499054] 06c7: OP5f
[codex:1499054] 06c8: DUP1
[codex:1499054] 06c9: PUSH1 0x20
[codex:1499054] 06cb: OP5f
[codex:1499054] 06cc: DUP5
[codex:1499054] 06cd: MLOAD
[codex:1499054] 06ce: PUSH1 0x20
[codex:1499054] 06d0: DUP7
[codex:1499054] 06d1: ADD
[codex:1499054] 06d2: OP5f
[codex:1499054] 06d3: DUP9
[codex:1499054] 06d4: GAS
[codex:1499054] 06d5: CALL
[codex:1499054] 06d6: DUP1
[codex:1499054] 
[codex:1499054] 
[codex:1499054] thinking
[codex:1499054] **Analyzing deposit/withdraw logic and storage updates**
[codex:1499054] thinking
[codex:1499054] **Investigating storage writes for balance tracking**
[codex:1499054] exec
[codex:1499054] /bin/bash -lc "python - <<'PY'
[codex:1499054] import re
[codex:1499054] hexstr=open('BYTECODE_BUNDLE.txt').read();
[codex:1499054] m=re.search(r'0x([0-9a-fA-F]+)', hexstr)
[codex:1499054] code=bytes.fromhex(m.group(1))
[codex:1499054] opmap={0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',0x20:'SHA3',0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'}
[codex:1499054] for i in range(1,33): opmap[0x5f+i]=f'PUSH{i}'
[codex:1499054] for i in range(1,17): opmap[0x7f+i]=f'DUP{i}'
[codex:1499054] for i in range(1,17): opmap[0x8f+i]=f'SWAP{i}'
[codex:1499054] 
[codex:1499054] out=[];off=0
[codex:1499054] while off<len(code):
[codex:1499054]     op=code[off];name=opmap.get(op,f'OP{op:02x}');off0=off;off+=1
[codex:1499054]     if name.startswith('PUSH'):
[codex:1499054]         n=int(name[4:]);arg=code[off:off+n];off+=n;out.append((off0,f'{name} 0x{arg.hex()}'))
[codex:1499054]     else: out.append((off0,name))
[codex:1499054] 
[codex:1499054] for off,name in out:
[codex:1499054]     if 0x0280<=off<=0x02c0:
[codex:1499054]         print(f'{off:04x}: {name}')
[codex:1499054] PY" in /tmp/codex-multi-fq9ccdne succeeded in 29ms:
[codex:1499054] 0280: PUSH1 0x64
[codex:1499054] 0282: DUP3
[codex:1499054] 0283: ADD
[codex:1499054] 0284: MSTORE
[codex:1499054] 0285: PUSH1 0x84
[codex:1499054] 0287: ADD
[codex:1499054] 0288: PUSH2 0x0221
[codex:1499054] 028b: JUMP
[codex:1499054] 028c: JUMPDEST
[codex:1499054] 028d: PUSH2 0x02a1
[codex:1499054] 0290: PUSH1 0x01
[codex:1499054] 0292: PUSH1 0x01
[codex:1499054] 0294: PUSH1 0xa0
[codex:1499054] 0296: SHL
[codex:1499054] 0297: SUB
[codex:1499054] 0298: DUP6
[codex:1499054] 0299: AND
[codex:1499054] 029a: DUP5
[codex:1499054] 029b: ADDRESS
[codex:1499054] 029c: DUP6
[codex:1499054] 
[codex:1499054] thinking
[codex:1499054] **Analyzing bytecode for vulnerabilities**
[codex:1499054] 
[codex:1499054] I'm carefully reviewing the bytecode patterns related to AccessControl, ReentrancyGuard, and SafeERC20 usage. So far, I don't see any concrete security issues like ledger mismatches or missing access control. The deposit and withdraw functions handle token transfers with safety checks, and role-based access is properly enforced. I’m preparing a JSON summary indicating no findings, as required.
[codex:1499054] codex
[codex:1499054] {"no_findings":true,"summary":"Reviewed runtime bytecode for concrete vulnerability patterns (AccessControl, ReentrancyGuard, SafeERC20-style calls observed); no actionable issues could be confirmed from bytecode/disasm alone.","findings":[]}
[codex:1499054] tokens used
[codex:1499054] 85,317
[codex:1499054] {"no_findings":true,"summary":"Reviewed runtime bytecode for concrete vulnerability patterns (AccessControl, ReentrancyGuard, SafeERC20-style calls observed); no actionable issues could be confirmed from bytecode/disasm alone.","findings":[]}

Metadata

{
    "codex": {
        "ran_at": "2025-12-29T23:53:25.820057+00:00",
        "returncode": 0
    },
    "summary": "Reviewed runtime bytecode for concrete vulnerability patterns (AccessControl, ReentrancyGuard, SafeERC20-style calls observed); no actionable issues could be confirmed from bytecode/disasm alone.",
    "raw_final": {
        "summary": "Reviewed runtime bytecode for concrete vulnerability patterns (AccessControl, ReentrancyGuard, SafeERC20-style calls observed); no actionable issues could be confirmed from bytecode/disasm alone.",
        "findings": [],
        "no_findings": true
    },
    "no_findings": true,
    "schema_version": 1
}

Opcode Heuristics

tool.cast_disasm

Delegatecall

0

Selfdestruct

0

CREATE2

0

CALL-family (heavy)

1

EXT*/BALANCE

1

Total opcodes

1299

Flags

No heuristic flags raised.

View cast disassembly output

00000000: PUSH1 0x80
00000002: PUSH1 0x40
00000004: MSTORE
00000005: CALLVALUE
00000006: DUP1
00000007: ISZERO
00000008: PUSH2 0x000f
0000000b: JUMPI
0000000c: PUSH0
0000000d: DUP1
0000000e: REVERT
0000000f: JUMPDEST
00000010: POP
00000011: PUSH1 0x04
00000013: CALLDATASIZE
00000014: LT
00000015: PUSH2 0x009b
00000018: JUMPI
00000019: PUSH0
0000001a: CALLDATALOAD
0000001b: PUSH1 0xe0
0000001d: SHR
0000001e: DUP1
0000001f: PUSH4 0x44004cc1
00000024: GT
00000025: PUSH2 0x0063
00000028: JUMPI
00000029: DUP1
0000002a: PUSH4 0x44004cc1
0000002f: EQ
00000030: PUSH2 0x0133
00000033: JUMPI
00000034: DUP1
00000035: PUSH4 0x91d14854
0000003a: EQ
0000003b: PUSH2 0x0146
0000003e: JUMPI
0000003f: DUP1
00000040: PUSH4 0xa217fddf
00000045: EQ
00000046: PUSH2 0x0159
00000049: JUMPI
0000004a: DUP1
0000004b: PUSH4 0xd547741f
00000050: EQ
00000051: PUSH2 0x0160
00000054: JUMPI
00000055: DUP1
00000056: PUSH4 0xff9e4f6c
0000005b: EQ
0000005c: PUSH2 0x0173
0000005f: JUMPI
00000060: PUSH0
00000061: DUP1
00000062: REVERT
00000063: JUMPDEST
00000064: DUP1
00000065: PUSH4 0x01ffc9a7
0000006a: EQ
0000006b: PUSH2 0x009f
0000006e: JUMPI
0000006f: DUP1
00000070: PUSH4 0x1cad5a40
00000075: EQ
00000076: PUSH2 0x00c7
00000079: JUMPI
0000007a: DUP1
0000007b: PUSH4 0x248a9ca3
00000080: EQ
00000081: PUSH2 0x00dc
00000084: JUMPI
00000085: DUP1
00000086: PUSH4 0x2f2ff15d
0000008b: EQ
0000008c: PUSH2 0x010d
0000008f: JUMPI
00000090: DUP1
00000091: PUSH4 0x36568abe
00000096: EQ
00000097: PUSH2 0x0120
0000009a: JUMPI
0000009b: JUMPDEST
0000009c: PUSH0
0000009d: DUP1
0000009e: REVERT
0000009f: JUMPDEST
000000a0: PUSH2 0x00b2
000000a3: PUSH2 0x00ad
000000a6: CALLDATASIZE
000000a7: PUSH1 0x04
000000a9: PUSH2 0x0732
000000ac: JUMP
000000ad: JUMPDEST
000000ae: PUSH2 0x019a
000000b1: JUMP
000000b2: JUMPDEST
000000b3: PUSH1 0x40
000000b5: MLOAD
000000b6: SWAP1
000000b7: ISZERO
000000b8: ISZERO
000000b9: DUP2
000000ba: MSTORE
000000bb: PUSH1 0x20
000000bd: ADD
000000be: JUMPDEST
000000bf: PUSH1 0x40
000000c1: MLOAD
000000c2: DUP1
000000c3: SWAP2
000000c4: SUB
000000c5: SWAP1
000000c6: RETURN
000000c7: JUMPDEST
000000c8: PUSH2 0x00da
000000cb: PUSH2 0x00d5
000000ce: CALLDATASIZE
000000cf: PUSH1 0x04
000000d1: PUSH2 0x0774
000000d4: JUMP
000000d5: JUMPDEST
000000d6: PUSH2 0x01d0
000000d9: JUMP
000000da: JUMPDEST
000000db: STOP
000000dc: JUMPDEST
000000dd: PUSH2 0x00ff
000000e0: PUSH2 0x00ea
000000e3: CALLDATASIZE
000000e4: PUSH1 0x04
000000e6: PUSH2 0x07b2
000000e9: JUMP
000000ea: JUMPDEST
000000eb: PUSH0
000000ec: SWAP1
000000ed: DUP2
000000ee: MSTORE
000000ef: PUSH1 0x01
000000f1: PUSH1 0x20
000000f3: DUP2
000000f4: SWAP1
000000f5: MSTORE
000000f6: PUSH1 0x40
000000f8: SWAP1
000000f9: SWAP2
000000fa: KECCAK256
000000fb: ADD
000000fc: SLOAD
000000fd: SWAP1
000000fe: JUMP
000000ff: JUMPDEST
00000100: PUSH1 0x40
00000102: MLOAD
00000103: SWAP1
00000104: DUP2
00000105: MSTORE
00000106: PUSH1 0x20
00000108: ADD
00000109: PUSH2 0x00be
0000010c: JUMP
0000010d: JUMPDEST
0000010e: PUSH2 0x00da
00000111: PUSH2 0x011b
00000114: CALLDATASIZE
00000115: PUSH1 0x04
00000117: PUSH2 0x07c9
0000011a: JUMP
0000011b: JUMPDEST
0000011c: PUSH2 0x030d
0000011f: JUMP
00000120: JUMPDEST
00000121: PUSH2 0x00da
00000124: PUSH2 0x012e
00000127: CALLDATASIZE
00000128: PUSH1 0x04
0000012a: PUSH2 0x07c9
0000012d: JUMP
0000012e: JUMPDEST
0000012f: PUSH2 0x0338
00000132: JUMP
00000133: JUMPDEST
00000134: PUSH2 0x00da
00000137: PUSH2 0x0141
0000013a: CALLDATASIZE
0000013b: PUSH1 0x04
0000013d: PUSH2 0x0774
00000140: JUMP
00000141: JUMPDEST
00000142: PUSH2 0x036b
00000145: JUMP
00000146: JUMPDEST
00000147: PUSH2 0x00b2
0000014a: PUSH2 0x0154
0000014d: CALLDATASIZE
0000014e: PUSH1 0x04
00000150: PUSH2 0x07c9
00000153: JUMP
00000154: JUMPDEST
00000155: PUSH2 0x048c
00000158: JUMP
00000159: JUMPDEST
0000015a: PUSH2 0x00ff
0000015d: PUSH0
0000015e: DUP2
0000015f: JUMP
00000160: JUMPDEST
00000161: PUSH2 0x00da
00000164: PUSH2 0x016e
00000167: CALLDATASIZE
00000168: PUSH1 0x04
0000016a: PUSH2 0x07c9
0000016d: JUMP
0000016e: JUMPDEST
0000016f: PUSH2 0x04b6
00000172: JUMP
00000173: JUMPDEST
00000174: PUSH2 0x00ff
00000177: PUSH32 0xc2949446873dcc27a43f979db2c832ea16ea1440ad63667d35ce8013841bb24b
00000198: DUP2
00000199: JUMP
0000019a: JUMPDEST
0000019b: PUSH0
0000019c: PUSH1 0x01
0000019e: PUSH1 0x01
000001a0: PUSH1 0xe0
000001a2: SHL
000001a3: SUB
000001a4: NOT
000001a5: DUP3
000001a6: AND
000001a7: PUSH4 0x7965db0b
000001ac: PUSH1 0xe0
000001ae: SHL
000001af: EQ
000001b0: DUP1
000001b1: PUSH2 0x01ca
000001b4: JUMPI
000001b5: POP
000001b6: PUSH4 0x01ffc9a7
000001bb: PUSH1 0xe0
000001bd: SHL
000001be: PUSH1 0x01
000001c0: PUSH1 0x01
000001c2: PUSH1 0xe0
000001c4: SHL
000001c5: SUB
000001c6: NOT
000001c7: DUP4
000001c8: AND
000001c9: EQ
000001ca: JUMPDEST
000001cb: SWAP3
000001cc: SWAP2
000001cd: POP
000001ce: POP
000001cf: JUMP
000001d0: JUMPDEST
000001d1: PUSH2 0x01d8
000001d4: PUSH2 0x04db
000001d7: JUMP
000001d8: JUMPDEST
000001d9: PUSH32 0xc2949446873dcc27a43f979db2c832ea16ea1440ad63667d35ce8013841bb24b
000001fa: PUSH2 0x0202
000001fd: DUP2
000001fe: PUSH2 0x0503
00000201: JUMP
00000202: JUMPDEST
00000203: PUSH0
00000204: DUP3
00000205: GT
00000206: PUSH2 0x022a
00000209: JUMPI
0000020a: PUSH1 0x40
0000020c: MLOAD
0000020d: PUSH3 0x461bcd
00000211: PUSH1 0xe5
00000213: SHL
00000214: DUP2
00000215: MSTORE
00000216: PUSH1 0x04
00000218: ADD
00000219: PUSH2 0x0221
0000021c: SWAP1
0000021d: PUSH2 0x07f7
00000220: JUMP
00000221: JUMPDEST
00000222: PUSH1 0x40
00000224: MLOAD
00000225: DUP1
00000226: SWAP2
00000227: SUB
00000228: SWAP1
00000229: REVERT
0000022a: JUMPDEST
0000022b: PUSH1 0x01
0000022d: PUSH1 0x01
0000022f: PUSH1 0xa0
00000231: SHL
00000232: SUB
00000233: DUP4
00000234: AND
00000235: PUSH2 0x028c
00000238: JUMPI
00000239: PUSH1 0x40
0000023b: MLOAD
0000023c: PUSH3 0x461bcd
00000240: PUSH1 0xe5
00000242: SHL
00000243: DUP2
00000244: MSTORE
00000245: PUSH1 0x20
00000247: PUSH1 0x04
00000249: DUP3
0000024a: ADD
0000024b: MSTORE
0000024c: PUSH1 0x23
0000024e: PUSH1 0x24
00000250: DUP3
00000251: ADD
00000252: MSTORE
00000253: PUSH32 0x42616e6b3a2073656e64657220616464726573732063616e6e6f74206265207a
00000274: PUSH1 0x44
00000276: DUP3
00000277: ADD
00000278: MSTORE
00000279: PUSH3 0x65726f
0000027d: PUSH1 0xe8
0000027f: SHL
00000280: PUSH1 0x64
00000282: DUP3
00000283: ADD
00000284: MSTORE
00000285: PUSH1 0x84
00000287: ADD
00000288: PUSH2 0x0221
0000028b: JUMP
0000028c: JUMPDEST
0000028d: PUSH2 0x02a1
00000290: PUSH1 0x01
00000292: PUSH1 0x01
00000294: PUSH1 0xa0
00000296: SHL
00000297: SUB
00000298: DUP6
00000299: AND
0000029a: DUP5
0000029b: ADDRESS
0000029c: DUP6
0000029d: PUSH2 0x0510
000002a0: JUMP
000002a1: JUMPDEST
000002a2: DUP3
000002a3: PUSH1 0x01
000002a5: PUSH1 0x01
000002a7: PUSH1 0xa0
000002a9: SHL
000002aa: SUB
000002ab: AND
000002ac: DUP5
000002ad: PUSH1 0x01
000002af: PUSH1 0x01
000002b1: PUSH1 0xa0
000002b3: SHL
000002b4: SUB
000002b5: AND
000002b6: PUSH1 0x02
000002b8: PUSH0
000002b9: DUP2
000002ba: SLOAD
000002bb: DUP1
000002bc: SWAP3
000002bd: SWAP2
000002be: SWAP1
000002bf: PUSH2 0x02c7
000002c2: SWAP1
000002c3: PUSH2 0x083d
000002c6: JUMP
000002c7: JUMPDEST
000002c8: SWAP1
000002c9: SWAP2
000002ca: SSTORE
000002cb: POP
000002cc: PUSH1 0x40
000002ce: MLOAD
000002cf: DUP6
000002d0: DUP2
000002d1: MSTORE
000002d2: PUSH32 0x54b55b0dca2281471c1e9b3db0a1397b951657e8c4c8551f4b26316d1408097d
000002f3: SWAP1
000002f4: PUSH1 0x20
000002f6: ADD
000002f7: PUSH1 0x40
000002f9: MLOAD
000002fa: DUP1
000002fb: SWAP2
000002fc: SUB
000002fd: SWAP1
000002fe: LOG4
000002ff: POP
00000300: PUSH2 0x0308
00000303: PUSH1 0x01
00000305: PUSH0
00000306: SSTORE
00000307: JUMP
00000308: JUMPDEST
00000309: POP
0000030a: POP
0000030b: POP
0000030c: JUMP
0000030d: JUMPDEST
0000030e: PUSH0
0000030f: DUP3
00000310: DUP2
00000311: MSTORE
00000312: PUSH1 0x01
00000314: PUSH1 0x20
00000316: DUP2
00000317: SWAP1
00000318: MSTORE
00000319: PUSH1 0x40
0000031b: SWAP1
0000031c: SWAP2
0000031d: KECCAK256
0000031e: ADD
0000031f: SLOAD
00000320: PUSH2 0x0328
00000323: DUP2
00000324: PUSH2 0x0503
00000327: JUMP
00000328: JUMPDEST
00000329: PUSH2 0x0332
0000032c: DUP4
0000032d: DUP4
0000032e: PUSH2 0x0577
00000331: JUMP
00000332: JUMPDEST
00000333: POP
00000334: POP
00000335: POP
00000336: POP
00000337: JUMP
00000338: JUMPDEST
00000339: PUSH1 0x01
0000033b: PUSH1 0x01
0000033d: PUSH1 0xa0
0000033f: SHL
00000340: SUB
00000341: DUP2
00000342: AND
00000343: CALLER
00000344: EQ
00000345: PUSH2 0x0361
00000348: JUMPI
00000349: PUSH1 0x40
0000034b: MLOAD
0000034c: PUSH4 0x334bd919
00000351: PUSH1 0xe1
00000353: SHL
00000354: DUP2
00000355: MSTORE
00000356: PUSH1 0x04
00000358: ADD
00000359: PUSH1 0x40
0000035b: MLOAD
0000035c: DUP1
0000035d: SWAP2
0000035e: SUB
0000035f: SWAP1
00000360: REVERT
00000361: JUMPDEST
00000362: PUSH2 0x0308
00000365: DUP3
00000366: DUP3
00000367: PUSH2 0x05ed
0000036a: JUMP
0000036b: JUMPDEST
0000036c: PUSH2 0x0373
0000036f: PUSH2 0x04db
00000372: JUMP
00000373: JUMPDEST
00000374: PUSH32 0xc2949446873dcc27a43f979db2c832ea16ea1440ad63667d35ce8013841bb24b
00000395: PUSH2 0x039d
00000398: DUP2
00000399: PUSH2 0x0503
0000039c: JUMP
0000039d: JUMPDEST
0000039e: PUSH1 0x01
000003a0: PUSH1 0x01
000003a2: PUSH1 0xa0
000003a4: SHL
000003a5: SUB
000003a6: DUP4
000003a7: AND
000003a8: PUSH2 0x0402
000003ab: JUMPI
000003ac: PUSH1 0x40
000003ae: MLOAD
000003af: PUSH3 0x461bcd
000003b3: PUSH1 0xe5
000003b5: SHL
000003b6: DUP2
000003b7: MSTORE
000003b8: PUSH1 0x20
000003ba: PUSH1 0x04
000003bc: DUP3
000003bd: ADD
000003be: MSTORE
000003bf: PUSH1 0x26
000003c1: PUSH1 0x24
000003c3: DUP3
000003c4: ADD
000003c5: MSTORE
000003c6: PUSH32 0x42616e6b3a20726563697069656e7420616464726573732063616e6e6f742062
000003e7: PUSH1 0x44
000003e9: DUP3
000003ea: ADD
000003eb: MSTORE
000003ec: PUSH6 0x65207a65726f
000003f3: PUSH1 0xd0
000003f5: SHL
000003f6: PUSH1 0x64
000003f8: DUP3
000003f9: ADD
000003fa: MSTORE
000003fb: PUSH1 0x84
000003fd: ADD
000003fe: PUSH2 0x0221
00000401: JUMP
00000402: JUMPDEST
00000403: PUSH0
00000404: DUP3
00000405: GT
00000406: PUSH2 0x0421
00000409: JUMPI
0000040a: PUSH1 0x40
0000040c: MLOAD
0000040d: PUSH3 0x461bcd
00000411: PUSH1 0xe5
00000413: SHL
00000414: DUP2
00000415: MSTORE
00000416: PUSH1 0x04
00000418: ADD
00000419: PUSH2 0x0221
0000041c: SWAP1
0000041d: PUSH2 0x07f7
00000420: JUMP
00000421: JUMPDEST
00000422: PUSH2 0x0435
00000425: PUSH1 0x01
00000427: PUSH1 0x01
00000429: PUSH1 0xa0
0000042b: SHL
0000042c: SUB
0000042d: DUP6
0000042e: AND
0000042f: DUP5
00000430: DUP5
00000431: PUSH2 0x0658
00000434: JUMP
00000435: JUMPDEST
00000436: DUP3
00000437: PUSH1 0x01
00000439: PUSH1 0x01
0000043b: PUSH1 0xa0
0000043d: SHL
0000043e: SUB
0000043f: AND
00000440: DUP5
00000441: PUSH1 0x01
00000443: PUSH1 0x01
00000445: PUSH1 0xa0
00000447: SHL
00000448: SUB
00000449: AND
0000044a: PUSH32 0xbfed55bdcd242e3dd0f60ddd7d1e87c67f61c34cd9527b3e6455d841b1025362
0000046b: DUP5
0000046c: PUSH1 0x40
0000046e: MLOAD
0000046f: PUSH2 0x047a
00000472: SWAP2
00000473: DUP2
00000474: MSTORE
00000475: PUSH1 0x20
00000477: ADD
00000478: SWAP1
00000479: JUMP
0000047a: JUMPDEST
0000047b: PUSH1 0x40
0000047d: MLOAD
0000047e: DUP1
0000047f: SWAP2
00000480: SUB
00000481: SWAP1
00000482: LOG3
00000483: POP
00000484: PUSH2 0x0308
00000487: PUSH1 0x01
00000489: PUSH0
0000048a: SSTORE
0000048b: JUMP
0000048c: JUMPDEST
0000048d: PUSH0
0000048e: SWAP2
0000048f: DUP3
00000490: MSTORE
00000491: PUSH1 0x01
00000493: PUSH1 0x20
00000495: SWAP1
00000496: DUP2
00000497: MSTORE
00000498: PUSH1 0x40
0000049a: DUP1
0000049b: DUP5
0000049c: KECCAK256
0000049d: PUSH1 0x01
0000049f: PUSH1 0x01
000004a1: PUSH1 0xa0
000004a3: SHL
000004a4: SUB
000004a5: SWAP4
000004a6: SWAP1
000004a7: SWAP4
000004a8: AND
000004a9: DUP5
000004aa: MSTORE
000004ab: SWAP2
000004ac: SWAP1
000004ad: MSTORE
000004ae: SWAP1
000004af: KECCAK256
000004b0: SLOAD
000004b1: PUSH1 0xff
000004b3: AND
000004b4: SWAP1
000004b5: JUMP
000004b6: JUMPDEST
000004b7: PUSH0
000004b8: DUP3
000004b9: DUP2
000004ba: MSTORE
000004bb: PUSH1 0x01
000004bd: PUSH1 0x20
000004bf: DUP2
000004c0: SWAP1
000004c1: MSTORE
000004c2: PUSH1 0x40
000004c4: SWAP1
000004c5: SWAP2
000004c6: KECCAK256
000004c7: ADD
000004c8: SLOAD
000004c9: PUSH2 0x04d1
000004cc: DUP2
000004cd: PUSH2 0x0503
000004d0: JUMP
000004d1: JUMPDEST
000004d2: PUSH2 0x0332
000004d5: DUP4
000004d6: DUP4
000004d7: PUSH2 0x05ed
000004da: JUMP
000004db: JUMPDEST
000004dc: PUSH1 0x02
000004de: PUSH0
000004df: SLOAD
000004e0: SUB
000004e1: PUSH2 0x04fd
000004e4: JUMPI
000004e5: PUSH1 0x40
000004e7: MLOAD
000004e8: PUSH4 0x3ee5aeb5
000004ed: PUSH1 0xe0
000004ef: SHL
000004f0: DUP2
000004f1: MSTORE
000004f2: PUSH1 0x04
000004f4: ADD
000004f5: PUSH1 0x40
000004f7: MLOAD
000004f8: DUP1
000004f9: SWAP2
000004fa: SUB
000004fb: SWAP1
000004fc: REVERT
000004fd: JUMPDEST
000004fe: PUSH1 0x02
00000500: PUSH0
00000501: SSTORE
00000502: JUMP
00000503: JUMPDEST
00000504: PUSH2 0x050d
00000507: DUP2
00000508: CALLER
00000509: PUSH2 0x0689
0000050c: JUMP
0000050d: JUMPDEST
0000050e: POP
0000050f: JUMP
00000510: JUMPDEST
00000511: PUSH1 0x40
00000513: MLOAD
00000514: PUSH1 0x01
00000516: PUSH1 0x01
00000518: PUSH1 0xa0
0000051a: SHL
0000051b: SUB
0000051c: DUP5
0000051d: DUP2
0000051e: AND
0000051f: PUSH1 0x24
00000521: DUP4
00000522: ADD
00000523: MSTORE
00000524: DUP4
00000525: DUP2
00000526: AND
00000527: PUSH1 0x44
00000529: DUP4
0000052a: ADD
0000052b: MSTORE
0000052c: PUSH1 0x64
0000052e: DUP3
0000052f: ADD
00000530: DUP4
00000531: SWAP1
00000532: MSTORE
00000533: PUSH2 0x0332
00000536: SWAP2
00000537: DUP7
00000538: SWAP2
00000539: DUP3
0000053a: AND
0000053b: SWAP1
0000053c: PUSH4 0x23b872dd
00000541: SWAP1
00000542: PUSH1 0x84
00000544: ADD
00000545: JUMPDEST
00000546: PUSH1 0x40
00000548: MLOAD
00000549: PUSH1 0x20
0000054b: DUP2
0000054c: DUP4
0000054d: SUB
0000054e: SUB
0000054f: DUP2
00000550: MSTORE
00000551: SWAP1
00000552: PUSH1 0x40
00000554: MSTORE
00000555: SWAP2
00000556: POP
00000557: PUSH1 0xe0
00000559: SHL
0000055a: PUSH1 0x20
0000055c: DUP3
0000055d: ADD
0000055e: DUP1
0000055f: MLOAD
00000560: PUSH1 0x01
00000562: PUSH1 0x01
00000564: PUSH1 0xe0
00000566: SHL
00000567: SUB
00000568: DUP4
00000569: DUP2
0000056a: DUP4
0000056b: AND
0000056c: OR
0000056d: DUP4
0000056e: MSTORE
0000056f: POP
00000570: POP
00000571: POP
00000572: POP
00000573: PUSH2 0x06c6
00000576: JUMP
00000577: JUMPDEST
00000578: PUSH0
00000579: PUSH2 0x0582
0000057c: DUP4
0000057d: DUP4
0000057e: PUSH2 0x048c
00000581: JUMP
00000582: JUMPDEST
00000583: PUSH2 0x05e6
00000586: JUMPI
00000587: PUSH0
00000588: DUP4
00000589: DUP2
0000058a: MSTORE
0000058b: PUSH1 0x01
0000058d: PUSH1 0x20
0000058f: DUP2
00000590: DUP2
00000591: MSTORE
00000592: PUSH1 0x40
00000594: DUP1
00000595: DUP5
00000596: KECCAK256
00000597: PUSH1 0x01
00000599: PUSH1 0x01
0000059b: PUSH1 0xa0
0000059d: SHL
0000059e: SUB
0000059f: DUP8
000005a0: AND
000005a1: DUP1
000005a2: DUP7
000005a3: MSTORE
000005a4: SWAP3
000005a5: MSTORE
000005a6: DUP1
000005a7: DUP5
000005a8: KECCAK256
000005a9: DUP1
000005aa: SLOAD
000005ab: PUSH1 0xff
000005ad: NOT
000005ae: AND
000005af: SWAP1
000005b0: SWAP4
000005b1: OR
000005b2: SWAP1
000005b3: SWAP3
000005b4: SSTORE
000005b5: SWAP1
000005b6: MLOAD
000005b7: CALLER
000005b8: SWAP3
000005b9: DUP7
000005ba: SWAP2
000005bb: PUSH32 0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d
000005dc: SWAP2
000005dd: SWAP1
000005de: LOG4
000005df: POP
000005e0: PUSH1 0x01
000005e2: PUSH2 0x01ca
000005e5: JUMP
000005e6: JUMPDEST
000005e7: POP
000005e8: PUSH0
000005e9: PUSH2 0x01ca
000005ec: JUMP
000005ed: JUMPDEST
000005ee: PUSH0
000005ef: PUSH2 0x05f8
000005f2: DUP4
000005f3: DUP4
000005f4: PUSH2 0x048c
000005f7: JUMP
000005f8: JUMPDEST
000005f9: ISZERO
000005fa: PUSH2 0x05e6
000005fd: JUMPI
000005fe: PUSH0
000005ff: DUP4
00000600: DUP2
00000601: MSTORE
00000602: PUSH1 0x01
00000604: PUSH1 0x20
00000606: SWAP1
00000607: DUP2
00000608: MSTORE
00000609: PUSH1 0x40
0000060b: DUP1
0000060c: DUP4
0000060d: KECCAK256
0000060e: PUSH1 0x01
00000610: PUSH1 0x01
00000612: PUSH1 0xa0
00000614: SHL
00000615: SUB
00000616: DUP7
00000617: AND
00000618: DUP1
00000619: DUP6
0000061a: MSTORE
0000061b: SWAP3
0000061c: MSTORE
0000061d: DUP1
0000061e: DUP4
0000061f: KECCAK256
00000620: DUP1
00000621: SLOAD
00000622: PUSH1 0xff
00000624: NOT
00000625: AND
00000626: SWAP1
00000627: SSTORE
00000628: MLOAD
00000629: CALLER
0000062a: SWAP3
0000062b: DUP7
0000062c: SWAP2
0000062d: PUSH32 0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b
0000064e: SWAP2
0000064f: SWAP1
00000650: LOG4
00000651: POP
00000652: PUSH1 0x01
00000654: PUSH2 0x01ca
00000657: JUMP
00000658: JUMPDEST
00000659: PUSH1 0x40
0000065b: MLOAD
0000065c: PUSH1 0x01
0000065e: PUSH1 0x01
00000660: PUSH1 0xa0
00000662: SHL
00000663: SUB
00000664: DUP4
00000665: DUP2
00000666: AND
00000667: PUSH1 0x24
00000669: DUP4
0000066a: ADD
0000066b: MSTORE
0000066c: PUSH1 0x44
0000066e: DUP3
0000066f: ADD
00000670: DUP4
00000671: SWAP1
00000672: MSTORE
00000673: PUSH2 0x0308
00000676: SWAP2
00000677: DUP6
00000678: SWAP2
00000679: DUP3
0000067a: AND
0000067b: SWAP1
0000067c: PUSH4 0xa9059cbb
00000681: SWAP1
00000682: PUSH1 0x64
00000684: ADD
00000685: PUSH2 0x0545
00000688: JUMP
00000689: JUMPDEST
0000068a: PUSH2 0x0693
0000068d: DUP3
0000068e: DUP3
0000068f: PUSH2 0x048c
00000692: JUMP
00000693: JUMPDEST
00000694: PUSH2 0x06c2
00000697: JUMPI
00000698: PUSH1 0x40
0000069a: MLOAD
0000069b: PUSH4 0xe2517d3f
000006a0: PUSH1 0xe0
000006a2: SHL
000006a3: DUP2
000006a4: MSTORE
000006a5: PUSH1 0x01
000006a7: PUSH1 0x01
000006a9: PUSH1 0xa0
000006ab: SHL
000006ac: SUB
000006ad: DUP3
000006ae: AND
000006af: PUSH1 0x04
000006b1: DUP3
000006b2: ADD
000006b3: MSTORE
000006b4: PUSH1 0x24
000006b6: DUP2
000006b7: ADD
000006b8: DUP4
000006b9: SWAP1
000006ba: MSTORE
000006bb: PUSH1 0x44
000006bd: ADD
000006be: PUSH2 0x0221
000006c1: JUMP
000006c2: JUMPDEST
000006c3: POP
000006c4: POP
000006c5: JUMP
000006c6: JUMPDEST
000006c7: PUSH0
000006c8: DUP1
000006c9: PUSH1 0x20
000006cb: PUSH0
000006cc: DUP5
000006cd: MLOAD
000006ce: PUSH1 0x20
000006d0: DUP7
000006d1: ADD
000006d2: PUSH0
000006d3: DUP9
000006d4: GAS
000006d5: CALL
000006d6: DUP1
000006d7: PUSH2 0x06e5
000006da: JUMPI
000006db: PUSH1 0x40
000006dd: MLOAD
000006de: RETURNDATASIZE
000006df: PUSH0
000006e0: DUP3
000006e1: RETURNDATACOPY
000006e2: RETURNDATASIZE
000006e3: DUP2
000006e4: REVERT
000006e5: JUMPDEST
000006e6: POP
000006e7: POP
000006e8: PUSH0
000006e9: MLOAD
000006ea: RETURNDATASIZE
000006eb: SWAP2
000006ec: POP
000006ed: DUP2
000006ee: ISZERO
000006ef: PUSH2 0x06fc
000006f2: JUMPI
000006f3: DUP1
000006f4: PUSH1 0x01
000006f6: EQ
000006f7: ISZERO
000006f8: PUSH2 0x0709
000006fb: JUMP
000006fc: JUMPDEST
000006fd: PUSH1 0x01
000006ff: PUSH1 0x01
00000701: PUSH1 0xa0
00000703: SHL
00000704: SUB
00000705: DUP5
00000706: AND
00000707: EXTCODESIZE
00000708: ISZERO
00000709: JUMPDEST
0000070a: ISZERO
0000070b: PUSH2 0x0332
0000070e: JUMPI
0000070f: PUSH1 0x40
00000711: MLOAD
00000712: PUSH4 0x5274afe7
00000717: PUSH1 0xe0
00000719: SHL
0000071a: DUP2
0000071b: MSTORE
0000071c: PUSH1 0x01
0000071e: PUSH1 0x01
00000720: PUSH1 0xa0
00000722: SHL
00000723: SUB
00000724: DUP6
00000725: AND
00000726: PUSH1 0x04
00000728: DUP3
00000729: ADD
0000072a: MSTORE
0000072b: PUSH1 0x24
0000072d: ADD
0000072e: PUSH2 0x0221
00000731: JUMP
00000732: JUMPDEST
00000733: PUSH0
00000734: PUSH1 0x20
00000736: DUP3
00000737: DUP5
00000738: SUB
00000739: SLT
0000073a: ISZERO
0000073b: PUSH2 0x0742
0000073e: JUMPI
0000073f: PUSH0
00000740: DUP1
00000741: REVERT
00000742: JUMPDEST
00000743: DUP2
00000744: CALLDATALOAD
00000745: PUSH1 0x01
00000747: PUSH1 0x01
00000749: PUSH1 0xe0
0000074b: SHL
0000074c: SUB
0000074d: NOT
0000074e: DUP2
0000074f: AND
00000750: DUP2
00000751: EQ
00000752: PUSH2 0x0759
00000755: JUMPI
00000756: PUSH0
00000757: DUP1
00000758: REVERT
00000759: JUMPDEST
0000075a: SWAP4
0000075b: SWAP3
0000075c: POP
0000075d: POP
0000075e: POP
0000075f: JUMP
00000760: JUMPDEST
00000761: PUSH1 0x01
00000763: PUSH1 0x01
00000765: PUSH1 0xa0
00000767: SHL
00000768: SUB
00000769: DUP2
0000076a: AND
0000076b: DUP2
0000076c: EQ
0000076d: PUSH2 0x050d
00000770: JUMPI
00000771: PUSH0
00000772: DUP1
00000773: REVERT
00000774: JUMPDEST
00000775: PUSH0
00000776: DUP1
00000777: PUSH0
00000778: PUSH1 0x60
0000077a: DUP5
0000077b: DUP7
0000077c: SUB
0000077d: SLT
0000077e: ISZERO
0000077f: PUSH2 0x0786
00000782: JUMPI
00000783: PUSH0
00000784: DUP1
00000785: REVERT
00000786: JUMPDEST
00000787: DUP4
00000788: CALLDATALOAD
00000789: PUSH2 0x0791
0000078c: DUP2
0000078d: PUSH2 0x0760
00000790: JUMP
00000791: JUMPDEST
00000792: SWAP3
00000793: POP
00000794: PUSH1 0x20
00000796: DUP5
00000797: ADD
00000798: CALLDATALOAD
00000799: PUSH2 0x07a1
0000079c: DUP2
0000079d: PUSH2 0x0760
000007a0: JUMP
000007a1: JUMPDEST
000007a2: SWAP3
000007a3: SWAP6
000007a4: SWAP3
000007a5: SWAP5
000007a6: POP
000007a7: POP
000007a8: POP
000007a9: PUSH1 0x40
000007ab: SWAP2
000007ac: SWAP1
000007ad: SWAP2
000007ae: ADD
000007af: CALLDATALOAD
000007b0: SWAP1
000007b1: JUMP
000007b2: JUMPDEST
000007b3: PUSH0
000007b4: PUSH1 0x20
000007b6: DUP3
000007b7: DUP5
000007b8: SUB
000007b9: SLT
000007ba: ISZERO
000007bb: PUSH2 0x07c2
000007be: JUMPI
000007bf: PUSH0
000007c0: DUP1
000007c1: REVERT
000007c2: JUMPDEST
000007c3: POP
000007c4: CALLDATALOAD
000007c5: SWAP2
000007c6: SWAP1
000007c7: POP
000007c8: JUMP
000007c9: JUMPDEST
000007ca: PUSH0
000007cb: DUP1
000007cc: PUSH1 0x40
000007ce: DUP4
000007cf: DUP6
000007d0: SUB
000007d1: SLT
000007d2: ISZERO
000007d3: PUSH2 0x07da
000007d6: JUMPI
000007d7: PUSH0
000007d8: DUP1
000007d9: REVERT
000007da: JUMPDEST
000007db: DUP3
000007dc: CALLDATALOAD
000007dd: SWAP2
000007de: POP
000007df: PUSH1 0x20
000007e1: DUP4
000007e2: ADD
000007e3: CALLDATALOAD
000007e4: PUSH2 0x07ec
000007e7: DUP2
000007e8: PUSH2 0x0760
000007eb: JUMP
000007ec: JUMPDEST
000007ed: DUP1
000007ee: SWAP2
000007ef: POP
000007f0: POP
000007f1: SWAP3
000007f2: POP
000007f3: SWAP3
000007f4: SWAP1
000007f5: POP
000007f6: JUMP
000007f7: JUMPDEST
000007f8: PUSH1 0x20
000007fa: DUP1
000007fb: DUP3
000007fc: MSTORE
000007fd: PUSH1 0x26
000007ff: SWAP1
00000800: DUP3
00000801: ADD
00000802: MSTORE
00000803: PUSH32 0x42616e6b3a20616d6f756e74206d757374206265206772656174657220746861
00000824: PUSH1 0x40
00000826: DUP3
00000827: ADD
00000828: MSTORE
00000829: PUSH6 0x6e207a65726f
00000830: PUSH1 0xd0
00000832: SHL
00000833: PUSH1 0x60
00000835: DUP3
00000836: ADD
00000837: MSTORE
00000838: PUSH1 0x80
0000083a: ADD
0000083b: SWAP1
0000083c: JUMP
0000083d: JUMPDEST
0000083e: PUSH0
0000083f: PUSH1 0x01
00000841: DUP3
00000842: ADD
00000843: PUSH2 0x085a
00000846: JUMPI
00000847: PUSH4 0x4e487b71
0000084c: PUSH1 0xe0
0000084e: SHL
0000084f: PUSH0
00000850: MSTORE
00000851: PUSH1 0x11
00000853: PUSH1 0x04
00000855: MSTORE
00000856: PUSH1 0x24
00000858: PUSH0
00000859: REVERT
0000085a: JUMPDEST
0000085b: POP
0000085c: PUSH1 0x01
0000085e: ADD
0000085f: SWAP1
00000860: JUMP
00000861: INVALID
00000862: LOG2
00000863: PUSH5 0x6970667358
00000869: UNKNOWN(0x22)
0000086a: SLT
0000086b: KECCAK256
0000086c: UNKNOWN(0xFC)
0000086d: PUSH8 0xc3de07073d0986de
00000876: SWAP5
00000877: UNKNOWN(0x4C)
00000878: SLOAD
00000879: UNKNOWN(0xA5)
0000087a: RETURNDATACOPY
0000087b: UNKNOWN(0xAA)
0000087c: UNKNOWN(0xC1)
0000087d: UNKNOWN(0xB8)
0000087e: CALLDATASIZE
0000087f: SWAP5
00000880: UNKNOWN(0x22)
00000881: DUP10
00000882: LOG4
00000883: DUP9
00000884: DUP11
00000885: UNKNOWN(0xB5)
00000886: UNKNOWN(0xCE)
00000887: UNKNOWN(0xEF)
00000888: UNKNOWN(0xAD)
00000889: SWAP1
0000088a: PUSH21

Findings

validated = confirmed for call sinks; sink observed for others

Severity	Category	Tool	Title	Confidence	Validated	Confirmed	Details
high	other	detector	ETH value transfer possible	55	no	no	view trace_id: 0x0d4f2e7df0010a107e235c8a018704990d3552ac03b91929778b857cb3333728 call_targets: 0x91a48de48c9f80bd1d79f5c22c3051478001b09f target_varies: no classification: constant_target validation_json { "sink": "CALL", "errors": 0, "status": "sink_reached", "attempts": 1, "trace_id": "0x0d4f2e7df0010a107e235c8a018704990d3552ac03b91929778b857cb3333728", "confirmed": false, "trace_mode": "callTracer", "call_targets": [ "0x91a48de48c9f80bd1d79f5c22c3051478001b09f" ], "matched_probe": null, "target_varies": false, "classification": "constant_target" } witness_json { "notes": "heuristic witness; entrypoints are best-effort selectors with zeroed calldata", "constraints": [], "entrypoints": [ { "calldata": "0x44004cc1", "selector": "0x44004cc1", "calldata_variants": [ "0x44004cc1", "0x44004cc10000000000000000000000000000000000000000000000000000000000000000" ] }, { "calldata": "0x91d14854", "selector": "0x91d14854", "calldata_variants": [ "0x91d14854", "0x91d148540000000000000000000000000000000000000000000000000000000000000000" ] }, { "calldata": "0xa217fddf", "selector": "0xa217fddf", "calldata_variants": [ "0xa217fddf", "0xa217fddf0000000000000000000000000000000000000000000000000000000000000000" ] }, { "calldata": "0xd547741f", "selector": "0xd547741f", "calldata_variants": [ "0xd547741f", "0xd547741f0000000000000000000000000000000000000000000000000000000000000000" ] }, { "calldata": "0xff9e4f6c", "selector": "0xff9e4f6c", "calldata_variants": [ "0xff9e4f6c", "0xff9e4f6c0000000000000000000000000000000000000000000000000000000000000000" ] }, { "calldata": "0x01ffc9a7", "selector": "0x01ffc9a7", "calldata_variants": [ "0x01ffc9a7", "0x01ffc9a70000000000000000000000000000000000000000000000000000000000000000" ] }, { "calldata": "0x1cad5a40", "selector": "0x1cad5a40", "calldata_variants": [ "0x1cad5a40", "0x1cad5a400000000000000000000000000000000000000000000000000000000000000000" ] }, { "calldata": "0x248a9ca3", "selector": "0x248a9ca3", "calldata_variants": [ "0x248a9ca3", "0x248a9ca30000000000000000000000000000000000000000000000000000000000000000" ] } ] } evidence_json { "examples": [ { "pc": 1749, "opcode": "CALL", "returndata_checked": null, "value_expression_category": "computed", "target_expression_category": "computed" } ], "eth_value_calls": 1, "guards_detected": [] }
high	other	detector	Untrusted CALL target/value reachable	60	no	no	view trace_id: 0x0d4f2e7df0010a107e235c8a018704990d3552ac03b91929778b857cb3333728 call_targets: 0x91a48de48c9f80bd1d79f5c22c3051478001b09f target_varies: no classification: constant_target validation_json { "sink": "CALL", "errors": 0, "status": "sink_reached", "attempts": 1, "trace_id": "0x0d4f2e7df0010a107e235c8a018704990d3552ac03b91929778b857cb3333728", "confirmed": false, "trace_mode": "callTracer", "call_targets": [ "0x91a48de48c9f80bd1d79f5c22c3051478001b09f" ], "matched_probe": null, "target_varies": false, "classification": "constant_target" } witness_json { "notes": "heuristic witness; entrypoints are best-effort selectors with zeroed calldata", "constraints": [], "entrypoints": [ { "calldata": "0x44004cc1", "selector": "0x44004cc1", "calldata_variants": [ "0x44004cc1", "0x44004cc10000000000000000000000000000000000000000000000000000000000000000" ] }, { "calldata": "0x91d14854", "selector": "0x91d14854", "calldata_variants": [ "0x91d14854", "0x91d148540000000000000000000000000000000000000000000000000000000000000000" ] }, { "calldata": "0xa217fddf", "selector": "0xa217fddf", "calldata_variants": [ "0xa217fddf", "0xa217fddf0000000000000000000000000000000000000000000000000000000000000000" ] }, { "calldata": "0xd547741f", "selector": "0xd547741f", "calldata_variants": [ "0xd547741f", "0xd547741f0000000000000000000000000000000000000000000000000000000000000000" ] }, { "calldata": "0xff9e4f6c", "selector": "0xff9e4f6c", "calldata_variants": [ "0xff9e4f6c", "0xff9e4f6c0000000000000000000000000000000000000000000000000000000000000000" ] }, { "calldata": "0x01ffc9a7", "selector": "0x01ffc9a7", "calldata_variants": [ "0x01ffc9a7", "0x01ffc9a70000000000000000000000000000000000000000000000000000000000000000" ] }, { "calldata": "0x1cad5a40", "selector": "0x1cad5a40", "calldata_variants": [ "0x1cad5a40", "0x1cad5a400000000000000000000000000000000000000000000000000000000000000000" ] }, { "calldata": "0x248a9ca3", "selector": "0x248a9ca3", "calldata_variants": [ "0x248a9ca3", "0x248a9ca30000000000000000000000000000000000000000000000000000000000000000" ] } ] } evidence_json { "examples": [ { "pc": 1749, "opcode": "CALL", "returndata_checked": null, "value_expression_category": "computed", "target_expression_category": "computed" } ], "call_count": 1, "guards_detected": [], "untrusted_call_count": 1 }

Severity