From 0b33af2e179efca8cf68f0bc463c2d367bce43d1 Mon Sep 17 00:00:00 2001 From: lmittmann Date: Mon, 31 Mar 2025 21:53:53 +0200 Subject: [PATCH 01/11] added experimental callframe tracer --- w3vm/hooks/call_frame_tracer.go | 209 ++++++++++++++++++++++++++++++++ 1 file changed, 209 insertions(+) create mode 100644 w3vm/hooks/call_frame_tracer.go diff --git a/w3vm/hooks/call_frame_tracer.go b/w3vm/hooks/call_frame_tracer.go new file mode 100644 index 00000000..cb41d309 --- /dev/null +++ b/w3vm/hooks/call_frame_tracer.go @@ -0,0 +1,209 @@ +package hooks + +import ( + "bytes" + "fmt" + "io" + "iter" + "math/big" + "os" + "slices" + + "github.com/charmbracelet/lipgloss" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/tracing" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/core/vm" + "github.com/lmittmann/w3" + "github.com/lmittmann/w3/internal/fourbyte" +) + +type CallFrame struct { + Type vm.OpCode + Depth int + PC uint64 + + From common.Address + Gas uint64 + GasUsed uint64 + To common.Address + Value *big.Int + Input []byte + Output []byte + + Reverted bool + Err error + Logs []*types.Log + Calls []*CallFrame +} + +func (cf *CallFrame) Iter() iter.Seq[*CallFrame] { + return func(yield func(*CallFrame) bool) { + stack := []*CallFrame{cf} + for len(stack) > 0 { + peek := stack[len(stack)-1] + stack = stack[:len(stack)-1] // pop + if !yield(peek) { + return + } + + for _, call := range slices.Backward(peek.Calls) { + stack = append(stack, call) // push + } + } + } +} + +func (cf *CallFrame) IterLogs() iter.Seq[*types.Log] { + return func(yield func(*types.Log) bool) { + logs := make([]*types.Log, 0) + for call := range cf.Iter() { + logs = append(logs, call.Logs...) + } + + slices.SortFunc(logs, func(a, b *types.Log) int { + return int(a.Index - b.Index) + }) + + for _, log := range logs { + if !yield(log) { + return + } + } + } +} + +type CallFrameTracer struct { + Call *CallFrame + + lastPC uint64 + logIdx int + stack []*CallFrame +} + +func NewCallFrameTracer() *CallFrameTracer { return new(CallFrameTracer) } + +func (t *CallFrameTracer) Hooks() *tracing.Hooks { + t.lastPC = 0 + t.logIdx = 0 + if t.stack == nil { + t.stack = make([]*CallFrame, 0) + } else { + t.stack = t.stack[:0] + } + + return &tracing.Hooks{ + OnEnter: t.onEnter, + OnExit: t.onExit, + OnOpcode: t.onOpcodes, + OnLog: t.onLog, + } +} + +func (t *CallFrameTracer) onEnter(depth int, typ byte, from common.Address, to common.Address, input []byte, gas uint64, value *big.Int) { + call := &CallFrame{ + Type: vm.OpCode(typ), + Depth: depth, + PC: t.lastPC, + From: from, + To: to, + Input: bytes.Clone(input), + Gas: gas, + Value: value, + } + if depth == 0 { + t.Call = call + } else { + peek := t.stack[len(t.stack)-1] + peek.Calls = append(peek.Calls, call) + } + + t.stack = append(t.stack, call) // push +} + +func (t *CallFrameTracer) onExit(depth int, output []byte, gasUsed uint64, err error, reverted bool) { + peek := t.stack[len(t.stack)-1] + peek.GasUsed = gasUsed + peek.Output = bytes.Clone(output) + peek.Reverted = reverted + peek.Err = err + t.stack = t.stack[:len(t.stack)-1] // pop +} + +func (t *CallFrameTracer) onOpcodes(pc uint64, op byte, gas, cost uint64, scope tracing.OpContext, rData []byte, depth int, err error) { + t.lastPC = pc +} + +func (t *CallFrameTracer) onLog(log *types.Log) { + peek := t.stack[len(t.stack)-1] + peek.Logs = append(peek.Logs, log) +} + +type PrintConfig struct { + TargetStyler func(addr common.Address) lipgloss.Style + targetAddr common.Address + + ShowStaticcall bool + ShowEvent bool + + DecodeABI bool +} + +func Print(cf *CallFrame, config *PrintConfig) { + Fprint(os.Stdout, cf, config) +} + +func Fprint(w io.Writer, cf *CallFrame, config *PrintConfig) { + config.targetAddr = cf.To + + callStack := make([]call, 0) + prettyPrint(w, cf, callStack, config) +} + +func prettyPrint(w io.Writer, cf *CallFrame, callStack []call, config *PrintConfig) { + var ( + fn *w3.Func + isPrecompile bool + ) + + if config.DecodeABI && len(cf.Input) >= 4 { + sig := ([4]byte)(cf.Input[:4]) + fn, isPrecompile = fourbyte.Function(sig, cf.To) + } + + // print call start + fmt.Fprint(w, + renderIdent(callStack, config.TargetStyler, 0), + renderAddr(cf.To, config.TargetStyler), + " ", + renderCallType(byte(cf.Type)), + renderValue(config.DecodeABI, cf.Value), + renderInput(fn, isPrecompile, cf.Input, config.TargetStyler), + "\n", + ) + + // push call to callStack + callStack = append(callStack, call{cf.Type, cf.To, fn}) + + for _, call := range cf.Calls { + prettyPrint(w, call, callStack, config) + } + + // print call end + fmt.Fprint(w, renderIdent(callStack, config.TargetStyler, -1)) + gasUsed := fmt.Sprintf("[%d]", cf.GasUsed) + if cf.Reverted { + fmt.Fprint(w, + styleRevert.Render(gasUsed), + " ", + renderRevert(cf.Err, cf.Output, config.DecodeABI), + ) + } else { + fmt.Fprint(w, + gasUsed, + " ", + renderOutput(fn, cf.Output, config.TargetStyler), + ) + } + fmt.Fprintln(w) +} From d8b5f8dd081e495b815717270682810f9bb13cd0 Mon Sep 17 00:00:00 2001 From: lmittmann Date: Mon, 31 Mar 2025 22:00:48 +0200 Subject: [PATCH 02/11] fix --- w3vm/hooks/call_frame_tracer.go | 43 +++++++++++++++++++++------------ 1 file changed, 27 insertions(+), 16 deletions(-) diff --git a/w3vm/hooks/call_frame_tracer.go b/w3vm/hooks/call_frame_tracer.go index cb41d309..52f453b3 100644 --- a/w3vm/hooks/call_frame_tracer.go +++ b/w3vm/hooks/call_frame_tracer.go @@ -139,7 +139,7 @@ func (t *CallFrameTracer) onLog(log *types.Log) { peek.Logs = append(peek.Logs, log) } -type PrintConfig struct { +type PrintOptions struct { TargetStyler func(addr common.Address) lipgloss.Style targetAddr common.Address @@ -149,36 +149,47 @@ type PrintConfig struct { DecodeABI bool } -func Print(cf *CallFrame, config *PrintConfig) { - Fprint(os.Stdout, cf, config) +func (opts *PrintOptions) targetStyler(addr common.Address) lipgloss.Style { + if addr == opts.targetAddr { + addr = TargetAddress + } + + if opts.TargetStyler == nil { + return defaultTargetStyler(addr) + } + return opts.TargetStyler(addr) +} + +func Print(cf *CallFrame, ops *PrintOptions) { + Fprint(os.Stdout, cf, ops) } -func Fprint(w io.Writer, cf *CallFrame, config *PrintConfig) { - config.targetAddr = cf.To +func Fprint(w io.Writer, cf *CallFrame, opts *PrintOptions) { + opts.targetAddr = cf.To callStack := make([]call, 0) - prettyPrint(w, cf, callStack, config) + prettyPrint(w, cf, callStack, opts) } -func prettyPrint(w io.Writer, cf *CallFrame, callStack []call, config *PrintConfig) { +func prettyPrint(w io.Writer, cf *CallFrame, callStack []call, opts *PrintOptions) { var ( fn *w3.Func isPrecompile bool ) - if config.DecodeABI && len(cf.Input) >= 4 { + if opts.DecodeABI && len(cf.Input) >= 4 { sig := ([4]byte)(cf.Input[:4]) fn, isPrecompile = fourbyte.Function(sig, cf.To) } // print call start fmt.Fprint(w, - renderIdent(callStack, config.TargetStyler, 0), - renderAddr(cf.To, config.TargetStyler), + renderIdent(callStack, opts.targetStyler, 0), + renderAddr(cf.To, opts.targetStyler), " ", renderCallType(byte(cf.Type)), - renderValue(config.DecodeABI, cf.Value), - renderInput(fn, isPrecompile, cf.Input, config.TargetStyler), + renderValue(opts.DecodeABI, cf.Value), + renderInput(fn, isPrecompile, cf.Input, opts.targetStyler), "\n", ) @@ -186,23 +197,23 @@ func prettyPrint(w io.Writer, cf *CallFrame, callStack []call, config *PrintConf callStack = append(callStack, call{cf.Type, cf.To, fn}) for _, call := range cf.Calls { - prettyPrint(w, call, callStack, config) + prettyPrint(w, call, callStack, opts) } // print call end - fmt.Fprint(w, renderIdent(callStack, config.TargetStyler, -1)) + fmt.Fprint(w, renderIdent(callStack, opts.targetStyler, -1)) gasUsed := fmt.Sprintf("[%d]", cf.GasUsed) if cf.Reverted { fmt.Fprint(w, styleRevert.Render(gasUsed), " ", - renderRevert(cf.Err, cf.Output, config.DecodeABI), + renderRevert(cf.Err, cf.Output, opts.DecodeABI), ) } else { fmt.Fprint(w, gasUsed, " ", - renderOutput(fn, cf.Output, config.TargetStyler), + renderOutput(fn, cf.Output, opts.targetStyler), ) } fmt.Fprintln(w) From 07ad562b7ce201f5d14006a74aee9da22b092af4 Mon Sep 17 00:00:00 2001 From: lmittmann Date: Mon, 31 Mar 2025 22:20:24 +0200 Subject: [PATCH 03/11] fix ident --- w3vm/hooks/call_frame_tracer.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/w3vm/hooks/call_frame_tracer.go b/w3vm/hooks/call_frame_tracer.go index 52f453b3..11a0f96a 100644 --- a/w3vm/hooks/call_frame_tracer.go +++ b/w3vm/hooks/call_frame_tracer.go @@ -184,7 +184,7 @@ func prettyPrint(w io.Writer, cf *CallFrame, callStack []call, opts *PrintOption // print call start fmt.Fprint(w, - renderIdent(callStack, opts.targetStyler, 0), + renderIdent(callStack, opts.targetStyler, 1), renderAddr(cf.To, opts.targetStyler), " ", renderCallType(byte(cf.Type)), From 666b72c7f6936f9e041dcd6470bca5e67a503100 Mon Sep 17 00:00:00 2001 From: lmittmann Date: Mon, 31 Mar 2025 22:24:34 +0200 Subject: [PATCH 04/11] respect ShowStatic = false --- w3vm/hooks/call_frame_tracer.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/w3vm/hooks/call_frame_tracer.go b/w3vm/hooks/call_frame_tracer.go index 11a0f96a..a42c022e 100644 --- a/w3vm/hooks/call_frame_tracer.go +++ b/w3vm/hooks/call_frame_tracer.go @@ -197,6 +197,9 @@ func prettyPrint(w io.Writer, cf *CallFrame, callStack []call, opts *PrintOption callStack = append(callStack, call{cf.Type, cf.To, fn}) for _, call := range cf.Calls { + if call.Type == vm.STATICCALL && !opts.ShowStaticcall { + continue + } prettyPrint(w, call, callStack, opts) } From 2088d4e75b37f0780fa5fdd40cddb2f89fcec503 Mon Sep 17 00:00:00 2001 From: lmittmann Date: Tue, 1 Apr 2025 13:17:00 +0200 Subject: [PATCH 05/11] internal/fourbyte: added more functions --- internal/fourbyte/funcs.go | 17 +++++++++++++++++ internal/fourbyte/funcs.txt | 17 +++++++++++++++++ 2 files changed, 34 insertions(+) diff --git a/internal/fourbyte/funcs.go b/internal/fourbyte/funcs.go index bdc5e77e..bd083865 100644 --- a/internal/fourbyte/funcs.go +++ b/internal/fourbyte/funcs.go @@ -5,6 +5,7 @@ import "github.com/lmittmann/w3" var functions = map[[4]byte]*w3.Func{ {0x01, 0xe3, 0x36, 0x67}: w3.MustNewFunc("withdrawToken(address token, address to, uint256 amount)", ""), + {0x01, 0xec, 0x95, 0x4a}: w3.MustNewFunc("onSwap((uint8 kind, address tokenIn, address tokenOut, uint256 amount, bytes32 poolId, uint256 lastChangeBlock, address from, address to, bytes userData) swapRequest, uint256[] balances, uint256 indexIn, uint256 indexOut)", "uint256 amount"), {0x01, 0xff, 0xc9, 0xa7}: w3.MustNewFunc("supportsInterface(bytes4)", "bool"), {0x02, 0x2c, 0x0d, 0x9f}: w3.MustNewFunc("swap(uint256 amount0Out, uint256 amount1Out, address to, bytes data)", ""), {0x02, 0x75, 0x1c, 0xec}: w3.MustNewFunc("removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline)", "uint256 amountToken, uint256 amountETH"), @@ -25,6 +26,7 @@ var functions = map[[4]byte]*w3.Func{ {0x12, 0x49, 0xc5, 0x8b}: w3.MustNewFunc("mint()", ""), {0x12, 0x8a, 0xcb, 0x08}: w3.MustNewFunc("swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, bytes data)", "int256 amount0, int256 amount1"), {0x13, 0xd7, 0x9a, 0x0b}: w3.MustNewFunc("settle(address[] tokens, uint256[] clearingPrices, (uint256 sellTokenIndex, uint256 buyTokenIndex, address receiver, uint256 sellAmount, uint256 buyAmount, uint32 validTo, bytes32 appData, uint256 feeAmount, uint256 flags, uint256 executedAmount, bytes signature)[] trades, (address target, uint256 value, bytes callData)[][3] interactions)", ""), + {0x14, 0xe7, 0xa7, 0xab}: w3.MustNewFunc("settleAggregate((uint256 expiry, address takerAddress, address[] makerAddresses, uint256[] makerNonces, address[][] takerTokens, address[][] makerTokens, uint256[][] takerAmounts, uint256[][] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags)[] makersSignatures, uint256 filledTakerAmount, (bool useOldAmount, uint256[][] makerAmounts, uint256[] makerNonces) takerQuoteInfo, bytes takerSignature)", ""), {0x15, 0x0b, 0x7a, 0x02}: w3.MustNewFunc("onERC721Received(address operator, address from, uint256 tokenId, bytes data)", "bytes4"), {0x16, 0x26, 0xba, 0x7e}: w3.MustNewFunc("isValidSignature(bytes32 hash, bytes data)", "bytes4 magic"), {0x17, 0x32, 0x60, 0xeb}: w3.MustNewFunc("settleInternal((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (uint256[] increasedBuyAmounts, uint16 curFillPercent) makerData)", ""), @@ -32,6 +34,7 @@ var functions = map[[4]byte]*w3.Func{ {0x18, 0x16, 0x0d, 0xdd}: w3.MustNewFunc("totalSupply()", "uint256"), {0x18, 0xcb, 0xaf, 0xe5}: w3.MustNewFunc("swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline)", "uint256[] amounts"), {0x18, 0xfd, 0xd0, 0x6b}: w3.MustNewFunc("getGrossAmountFromTotalSold(uint256 totalAmount)", "uint256"), + {0x1a, 0x49, 0x90, 0x26}: w3.MustNewFunc("settleSingle((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256 makerAmount, uint256 makerNonce) takerQuoteInfo, bytes takerSignature)", ""), {0x1a, 0x68, 0x65, 0x02}: w3.MustNewFunc("liquidity()", "uint128"), {0x1b, 0x9a, 0x91, 0xa4}: w3.MustNewFunc("withdrawEth(address to, uint256 amount)", ""), {0x1c, 0x56, 0x03, 0x05}: w3.MustNewFunc("claimMintRewardAndShare(address other, uint256 pct)", ""), @@ -55,8 +58,10 @@ var functions = map[[4]byte]*w3.Func{ {0x36, 0x44, 0xe5, 0x15}: w3.MustNewFunc("DOMAIN_SEPARATOR()", "bytes32"), {0x36, 0x56, 0x8a, 0xbe}: w3.MustNewFunc("renounceRole(bytes32 role, address account)", ""), {0x36, 0xc7, 0x85, 0x16}: w3.MustNewFunc("transferFrom(address from, address to, uint160 amount, address token)", ""), + {0x38, 0x4e, 0xad, 0xa0}: w3.MustNewFunc("settleMultiAndSignPermit((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address[] takerTokens, address[] makerTokens, uint256[] takerAmounts, uint256[] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256[] makerAmounts, uint256 makerNonce) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint256 deadline) takerPermitSignature)", ""), {0x38, 0x50, 0xc7, 0xbd}: w3.MustNewFunc("slot0()", "(uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint8 feeProtocol, bool unlocked)"), {0x38, 0xe9, 0x92, 0x2e}: w3.MustNewFunc("setSwapFeePercentage(uint256)", ""), + {0x38, 0xec, 0x02, 0x11}: w3.MustNewFunc("settleSingleAndSignPermit2((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256 makerAmount, uint256 makerNonce) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint48 deadline, uint48 nonce) takerPermit2Signature)", ""), {0x38, 0xed, 0x17, 0x39}: w3.MustNewFunc("swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline)", "uint256[] amounts"), {0x39, 0x47, 0x47, 0xc5}: w3.MustNewFunc("exchange(uint256 i, uint256 j, uint256 dx, uint256 min_dy, bool use_eth)", ""), {0x39, 0x50, 0x93, 0x51}: w3.MustNewFunc("increaseAllowance(address spender, uint256 addedValue)", "bool success"), @@ -82,6 +87,7 @@ var functions = map[[4]byte]*w3.Func{ {0x4a, 0x25, 0xd9, 0x4a}: w3.MustNewFunc("swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] path, address to, uint256 deadline)", "uint256[] amounts"), {0x4a, 0x2a, 0xb3, 0xbe}: w3.MustNewFunc("get_y(uint256 ANN, uint256 gamma, uint256[3] x, uint256 D, uint256 i)", "uint256[2]"), {0x4c, 0x84, 0xc1, 0xc8}: w3.MustNewFunc("wrapAll()", ""), + {0x4d, 0xce, 0xbc, 0xba}: w3.MustNewFunc("swapSingle((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount)", ""), {0x4e, 0x48, 0x7b, 0x71}: w3.MustNewFunc("Panic(uint256)", ""), {0x52, 0xbb, 0xbe, 0x29}: w3.MustNewFunc("swap((bytes32 poolId, uint8 swapKind, address assetIn, address assetOut, uint256 amount, bytes data) singleSwap, (address sender, bool fromInternalBalance, address recipient, bool toInternalBalance) funds, uint256 limit, uint256 deadline)", "uint256"), {0x52, 0xc7, 0xf8, 0xdc}: w3.MustNewFunc("claimMintReward()", ""), @@ -102,10 +108,12 @@ var functions = map[[4]byte]*w3.Func{ {0x5c, 0x97, 0x5a, 0xbb}: w3.MustNewFunc("paused()", "bool"), {0x5d, 0xed, 0x74, 0xa5}: w3.MustNewFunc("getGhoPriceInAsset(uint256 ghoAmount, bool roundUp)", "uint256"), {0x5e, 0x0d, 0x44, 0x3f}: w3.MustNewFunc("get_dy(int128 i, int128 j, uint256 amount)", "uint256"), + {0x60, 0x29, 0x26, 0xbf}: w3.MustNewFunc("swapMulti((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address[] takerTokens, address[] makerTokens, uint256[] takerAmounts, uint256[] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount)", ""), {0x60, 0x52, 0x97, 0xe1}: w3.MustNewFunc("seize()", "uint256"), {0x63, 0x52, 0x21, 0x1e}: w3.MustNewFunc("ownerOf(uint256 tokenId)", "address"), {0x64, 0x28, 0x3d, 0x7b}: w3.MustNewFunc("ERC721IncorrectOwner(address sender, uint256 tokenId, address owner)", ""), {0x64, 0xa0, 0xae, 0x92}: w3.MustNewFunc("ERC721InvalidReceiver(address receiver)", ""), + {0x66, 0xa6, 0x5e, 0x41}: w3.MustNewFunc("settleMultiAndSignPermit2((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address[] takerTokens, address[] makerTokens, uint256[] takerAmounts, uint256[] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256[] makerAmounts, uint256 makerNonce) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint48 deadline, uint48[] nonces) infoPermit2)", ""), {0x67, 0x5c, 0xae, 0x38}: w3.MustNewFunc("InsufficientToken()", ""), {0x69, 0x62, 0xf8, 0x45}: w3.MustNewFunc("mint_relative(address to, uint256 frac)", "uint256"), {0x6a, 0x12, 0xf1, 0x04}: w3.MustNewFunc("InsufficientETH()", ""), @@ -114,6 +122,7 @@ var functions = map[[4]byte]*w3.Func{ {0x70, 0xa0, 0x82, 0x31}: w3.MustNewFunc("balanceOf(address)", "uint256"), {0x71, 0x50, 0x18, 0xa6}: w3.MustNewFunc("renounceOwnership()", ""), {0x72, 0x84, 0xe4, 0x16}: w3.MustNewFunc("description()", "string"), + {0x72, 0xfc, 0x32, 0xe5}: w3.MustNewFunc("settleAggregateAndSignPermit2((uint256 expiry, address takerAddress, address[] makerAddresses, uint256[] makerNonces, address[][] takerTokens, address[][] makerTokens, uint256[][] takerAmounts, uint256[][] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags)[] makersSignatures, uint256 filledTakerAmount, (bool useOldAmount, uint256[][] makerAmounts, uint256[] makerNonces) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint48 deadline, uint48[] nonces) infoPermit2)", ""), {0x73, 0x9d, 0xbe, 0x52}: w3.MustNewFunc("V3TooMuchRequested()", ""), {0x73, 0xc6, 0xac, 0x6e}: w3.MustNewFunc("ERC721InvalidSender(address sender)", ""), {0x74, 0x64, 0xfc, 0x3d}: w3.MustNewFunc("kLast()", "uint256"), @@ -133,6 +142,7 @@ var functions = map[[4]byte]*w3.Func{ {0x7e, 0x27, 0x32, 0x89}: w3.MustNewFunc("ERC721NonexistentToken(uint256 tokenId)", ""), {0x7f, 0xf3, 0x6a, 0xb5}: w3.MustNewFunc("swapExactETHForTokens(uint256 amountOutMin, address[] path, address to, uint256 deadline)", "uint256[] amounts"), {0x81, 0xd1, 0x8d, 0x87}: w3.MustNewFunc("wad_exp(int256 power)", "uint256"), + {0x82, 0x5c, 0xab, 0xa1}: w3.MustNewFunc("cancelOrderRFQ(uint256 orderInfo)", ""), {0x83, 0xc4, 0xa1, 0x9d}: w3.MustNewFunc("swapTargets(address)", "bool"), {0x84, 0x9e, 0xaf, 0x98}: w3.MustNewFunc("V2TooLittleReceived()", ""), {0x85, 0x58, 0x59, 0xb4}: w3.MustNewFunc("ToUint24Overflow()", ""), @@ -143,6 +153,7 @@ var functions = map[[4]byte]*w3.Func{ {0x8a, 0xb0, 0xbc, 0x16}: w3.MustNewFunc("V2TooMuchRequested()", ""), {0x8d, 0xa5, 0xcb, 0x5b}: w3.MustNewFunc("owner()", "address"), {0x90, 0x10, 0xd0, 0x7c}: w3.MustNewFunc("getRoleMember(bytes32 role, uint256 index)", "address"), + {0x90, 0x93, 0xbf, 0x7b}: w3.MustNewFunc("settleAggregateAndSignPermit((uint256 expiry, address takerAddress, address[] makerAddresses, uint256[] makerNonces, address[][] takerTokens, address[][] makerTokens, uint256[][] takerAmounts, uint256[][] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags)[] makersSignatures, uint256 filledTakerAmount, (bool useOldAmount, uint256[][] makerAmounts, uint256[] makerNonces) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint256 deadline) takerPermitSignature)", ""), {0x91, 0xd1, 0x48, 0x54}: w3.MustNewFunc("hasRole(bytes32 role, address account)", "bool"), {0x92, 0x7d, 0xa1, 0x05}: w3.MustNewFunc("allowance(address user, address token, address spender)", "uint160 amount, uint48 expiration, uint48 nonce"), {0x94, 0x28, 0x0d, 0x62}: w3.MustNewFunc("ERC20InvalidSpender(address spender)", ""), @@ -161,6 +172,7 @@ var functions = map[[4]byte]*w3.Func{ {0xa2, 0x2c, 0xb4, 0x65}: w3.MustNewFunc("setApprovalForAll(address operator, bool approved)", ""), {0xa2, 0x3b, 0xa0, 0x9c}: w3.MustNewFunc("swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, uint256 amountLimit, uint256 deadline, uint256 trackingCode)", "int256 amount0, int256 amount1"), {0xa2, 0x62, 0x90, 0x4b}: w3.MustNewFunc("get_registry()", "address"), + {0xa2, 0xf7, 0x48, 0x93}: w3.MustNewFunc("swapAggregate((uint256 expiry, address takerAddress, address[] makerAddresses, uint256[] makerNonces, address[][] takerTokens, address[][] makerTokens, uint256[][] takerAmounts, uint256[][] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags)[] makersSignatures, uint256 filledTakerAmount)", ""), {0xa4, 0x57, 0xc2, 0xd7}: w3.MustNewFunc("decreaseAllowance(address spender, uint256 subtractedValue)", "bool success"), {0xa4, 0x98, 0x46, 0x33}: w3.MustNewFunc("crossLmTick(int24 tick, bool zeroForOne)", ""), {0xa4, 0xa2, 0x1f, 0xa2}: w3.MustNewFunc("getGrossAmountFromTotalBought(uint256 totalAmount)", "uint256"), @@ -183,10 +195,12 @@ var functions = map[[4]byte]*w3.Func{ {0xb8, 0x8d, 0x4f, 0xde}: w3.MustNewFunc("safeTransferFrom(address from, address to, uint256 tokenId, bytes data)", ""), {0xba, 0x9a, 0x7a, 0x56}: w3.MustNewFunc("MINIMUM_LIQUIDITY()", "uint256"), {0xba, 0xa2, 0xab, 0xde}: w3.MustNewFunc("removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline)", "uint256 amountA, uint256 amountB"), + {0xba, 0xba, 0x58, 0x55}: w3.MustNewFunc("fillOrderRFQTo((uint256 info, address makerAsset, address takerAsset, address maker, address allowedSender, uint256 makingAmount, uint256 takingAmount) order, bytes signature, uint256 makingAmount, uint256 takingAmount, address target)", ""), {0xba, 0xd1, 0xdc, 0x26}: w3.MustNewFunc("geometric_mean(uint256[3] x)", "uint256"), {0xbc, 0x25, 0xcf, 0x77}: w3.MustNewFunc("skim(address to)", ""), {0xbe, 0x00, 0xbb, 0xd8}: w3.MustNewFunc("getApp(bytes32 namespace, bytes32 appId)", "address"), {0xc3, 0x1b, 0x8d, 0x7a}: w3.MustNewFunc("swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96)", "int256 amount0, int256 amount1"), + {0xc3, 0x8a, 0x44, 0x74}: w3.MustNewFunc("swapSingleFromContract((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature)", ""), {0xc4, 0x5a, 0x01, 0x55}: w3.MustNewFunc("factory()", "address"), {0xc4, 0xbd, 0x89, 0xa9}: w3.MustNewFunc("UnsafeCast()", ""), {0xc6, 0x61, 0x06, 0x57}: w3.MustNewFunc("coins(uint256 i)", "address"), @@ -198,6 +212,7 @@ var functions = map[[4]byte]*w3.Func{ {0xce, 0x7d, 0x65, 0x03}: w3.MustNewFunc("exchange(uint256 i, uint256 j, uint256 dx, uint256 min_dy, bool use_eth, address receiver)", "uint256"), {0xce, 0xa9, 0xd2, 0x6f}: w3.MustNewFunc("rescueTokens(address token, address to, uint256 amount)", ""), {0xd0, 0x6c, 0xa6, 0x1f}: w3.MustNewFunc("getAmountsOut(uint256 amountIn, address[] path)", "uint256[] amounts"), + {0xd0, 0xa3, 0xb6, 0x65}: w3.MustNewFunc("fillOrderRFQ((uint256 info, address makerAsset, address takerAsset, address maker, address allowedSender, uint256 makingAmount, uint256 takingAmount) order, bytes signature, uint256 makingAmount, uint256 takingAmount)", ""), {0xd0, 0xc9, 0x3a, 0x7c}: w3.MustNewFunc("tickSpacing()", "int24"), {0xd0, 0xe3, 0x0d, 0xb0}: w3.MustNewFunc("deposit()", ""), {0xd2, 0x12, 0x20, 0xa7}: w3.MustNewFunc("token1()", "address"), @@ -222,6 +237,8 @@ var functions = map[[4]byte]*w3.Func{ {0xeb, 0x8d, 0x21, 0x16}: w3.MustNewFunc("transferTokens((address from, address receiver, address[] tokens, uint256[] amounts, uint256[] nftIds, bytes tokenTransferTypes, uint16 fillPercent) transferData)", ""), {0xec, 0x44, 0x2f, 0x05}: w3.MustNewFunc("ERC20InvalidReceiver(address receiver)", ""), {0xec, 0x98, 0x37, 0x76}: w3.MustNewFunc("settleWithPermitsSignatures((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, (bytes[] permitSignatures, bytes signatureBytesPermit2, uint48[] noncesPermit2, uint48 deadline) takerPermitsInfo, (bool result, address to, uint256 value, bytes data)[] interactions, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (address balanceRecipient, uint16 curFillPercent) solverData)", ""), + {0xef, 0x7d, 0x27, 0xad}: w3.MustNewFunc("settleSingleAndSignPermit((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256 makerAmount, uint256 makerNonce) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint256 deadline) takerPermitSignature)", ""), + {0xef, 0xe3, 0x4f, 0xe6}: w3.MustNewFunc("settleMulti((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address[] takerTokens, address[] makerTokens, uint256[] takerAmounts, uint256[] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256[] makerAmounts, uint256 makerNonce) takerQuoteInfo, bytes takerSignature)", ""), {0xf2, 0xfd, 0xe3, 0x8b}: w3.MustNewFunc("transferOwnership(address newOwner)", ""), {0xf3, 0x05, 0x83, 0x99}: w3.MustNewFunc("feeGrowthGlobal0X128()", "uint256"), {0xf3, 0x05, 0xd7, 0x19}: w3.MustNewFunc("addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline)", "uint256 amountToken, uint256 amountETH, uint256 liquidity"), diff --git a/internal/fourbyte/funcs.txt b/internal/fourbyte/funcs.txt index b219e224..22f7211f 100644 --- a/internal/fourbyte/funcs.txt +++ b/internal/fourbyte/funcs.txt @@ -15,6 +15,7 @@ burnAfterSeize(uint256 amount) uint256 burnFrom(address to, uint256 value) bool buyAsset(uint256 minAmount, address receiver) uint256, uint256 buyAssetWithSig(address originator, uint256 minAmount, address receiver, uint256 deadline, bytes signature) uint256, uint256 +cancelOrderRFQ(uint256 orderInfo) canPerform(bytes32 actionId, address account, address where) bool cbrt(uint256 x) uint256 claimMintReward() @@ -59,6 +60,8 @@ factory() address fee() uint24 feeGrowthGlobal0X128() uint256 feeGrowthGlobal1X128() uint256 +fillOrderRFQ((uint256 info, address makerAsset, address takerAsset, address maker, address allowedSender, uint256 makingAmount, uint256 takingAmount) order, bytes signature, uint256 makingAmount, uint256 takingAmount) +fillOrderRFQTo((uint256 info, address makerAsset, address takerAsset, address maker, address allowedSender, uint256 makingAmount, uint256 takingAmount) order, bytes signature, uint256 makingAmount, uint256 takingAmount, address target) fillQuoteEthToToken(address buyTokenAddress, address target, bytes swapCallData, uint256 feeAmount) fillQuoteTokenToEth(address sellTokenAddress, address target, bytes swapCallData, uint256 sellAmount, uint256 feePercentageBasisPoints) fillQuoteTokenToEthWithPermit(address sellTokenAddress, address target, bytes swapCallData, uint256 sellAmount, uint256 feePercentageBasisPoints, (uint256 value, uint256 nonce, uint256 deadline, bool isDaiStylePermit, uint8 v, bytes32 r, bytes32 s) permitData) @@ -126,6 +129,7 @@ name() string newton_D(uint256 ANN, uint256 gamma, uint256[3] x_unsorted, uint256 K0_prev) uint256 NoSlice() onERC721Received(address operator, address from, uint256 tokenId, bytes data) bytes4 +onSwap((uint8 kind, address tokenIn, address tokenOut, uint256 amount, bytes32 poolId, uint256 lastChangeBlock, address from, address to, bytes userData) swapRequest, uint256[] balances, uint256 indexIn, uint256 indexOut) uint256 amount owner() address ownerOf(uint256 tokenId) address pancakeV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes data) @@ -160,9 +164,18 @@ setSwapFeePercentage(uint256) setSwapFreeze(bool enable) settle((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, (bool result, address to, uint256 value, bytes data)[] interactions, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (address balanceRecipient, uint16 curFillPercent) solverData) settle(address[] tokens, uint256[] clearingPrices, (uint256 sellTokenIndex, uint256 buyTokenIndex, address receiver, uint256 sellAmount, uint256 buyAmount, uint32 validTo, bytes32 appData, uint256 feeAmount, uint256 flags, uint256 executedAmount, bytes signature)[] trades, (address target, uint256 value, bytes callData)[][3] interactions) +settleAggregate((uint256 expiry, address takerAddress, address[] makerAddresses, uint256[] makerNonces, address[][] takerTokens, address[][] makerTokens, uint256[][] takerAmounts, uint256[][] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags)[] makersSignatures, uint256 filledTakerAmount, (bool useOldAmount, uint256[][] makerAmounts, uint256[] makerNonces) takerQuoteInfo, bytes takerSignature) +settleAggregateAndSignPermit((uint256 expiry, address takerAddress, address[] makerAddresses, uint256[] makerNonces, address[][] takerTokens, address[][] makerTokens, uint256[][] takerAmounts, uint256[][] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags)[] makersSignatures, uint256 filledTakerAmount, (bool useOldAmount, uint256[][] makerAmounts, uint256[] makerNonces) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint256 deadline) takerPermitSignature) +settleAggregateAndSignPermit2((uint256 expiry, address takerAddress, address[] makerAddresses, uint256[] makerNonces, address[][] takerTokens, address[][] makerTokens, uint256[][] takerAmounts, uint256[][] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags)[] makersSignatures, uint256 filledTakerAmount, (bool useOldAmount, uint256[][] makerAmounts, uint256[] makerNonces) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint48 deadline, uint48[] nonces) infoPermit2) settleBatch((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers)[] orders, (uint8 type, bytes signatureBytes)[] signatures, (bytes[] permitSignatures, bytes signatureBytesPermit2, uint48[] noncesPermit2, uint48 deadline)[] takersPermitsInfo, (bool result, address to, uint256 value, bytes data)[] interactions, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle)[] hooks, (address balanceRecipient, uint16[] curFillPercents, bool[] takersPermitsUsage, bool transferExactAmounts) solverData) settleInternal((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (uint256[] increasedBuyAmounts, uint16 curFillPercent) makerData) settleInternalWithPermitsSignatures((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, (bytes[] permitSignatures, bytes signatureBytesPermit2, uint48[] noncesPermit2, uint48 deadline) takerPermitsInfo, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (uint256[] increasedBuyAmounts, uint16 curFillPercent) makerData) +settleMulti((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address[] takerTokens, address[] makerTokens, uint256[] takerAmounts, uint256[] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256[] makerAmounts, uint256 makerNonce) takerQuoteInfo, bytes takerSignature) +settleMultiAndSignPermit((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address[] takerTokens, address[] makerTokens, uint256[] takerAmounts, uint256[] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256[] makerAmounts, uint256 makerNonce) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint256 deadline) takerPermitSignature) +settleMultiAndSignPermit2((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address[] takerTokens, address[] makerTokens, uint256[] takerAmounts, uint256[] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256[] makerAmounts, uint256 makerNonce) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint48 deadline, uint48[] nonces) infoPermit2) +settleSingle((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256 makerAmount, uint256 makerNonce) takerQuoteInfo, bytes takerSignature) +settleSingleAndSignPermit((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256 makerAmount, uint256 makerNonce) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint256 deadline) takerPermitSignature) +settleSingleAndSignPermit2((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256 makerAmount, uint256 makerNonce) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint48 deadline, uint48 nonce) takerPermit2Signature) settleWithPermitsSignatures((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, (bytes[] permitSignatures, bytes signatureBytesPermit2, uint48[] noncesPermit2, uint48 deadline) takerPermitsInfo, (bool result, address to, uint256 value, bytes data)[] interactions, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (address balanceRecipient, uint16 curFillPercent) solverData) skim(address to) SliceOutOfBounds() @@ -180,6 +193,7 @@ swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPri swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, uint256 amountLimit, uint256 deadline, uint256 trackingCode) int256 amount0, int256 amount1 swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, uint256 trackingCode) int256 amount0, int256 amount1 swap(uint256 amount0Out, uint256 amount1Out, address to, bytes data) +swapAggregate((uint256 expiry, address takerAddress, address[] makerAddresses, uint256[] makerNonces, address[][] takerTokens, address[][] makerTokens, uint256[][] takerAmounts, uint256[][] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags)[] makersSignatures, uint256 filledTakerAmount) swapETHForExactTokens(uint256 amountOut, address[] path, address to, uint256 deadline) uint256[] amounts swapExactETHForTokens(uint256 amountOutMin, address[] path, address to, uint256 deadline) uint256[] amounts swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] path, address to, uint256 deadline) @@ -187,6 +201,9 @@ swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] path, ad swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline) swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline) uint256[] amounts swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline) +swapMulti((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address[] takerTokens, address[] makerTokens, uint256[] takerAmounts, uint256[] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount) +swapSingle((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount) +swapSingleFromContract((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature) swapTargets(address) bool swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] path, address to, uint256 deadline) uint256[] amounts swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] path, address to, uint256 deadline) uint256[] amounts From ee852196ff9fd46b083a20bbae8cf5af4648c157 Mon Sep 17 00:00:00 2001 From: lmittmann Date: Tue, 1 Apr 2025 14:49:06 +0200 Subject: [PATCH 06/11] internal/fourbyte: added funcs --- internal/fourbyte/funcs.go | 43 +++++++++++++++++++++++++++++++++++++ internal/fourbyte/funcs.txt | 43 +++++++++++++++++++++++++++++++++++++ 2 files changed, 86 insertions(+) diff --git a/internal/fourbyte/funcs.go b/internal/fourbyte/funcs.go index bd083865..58cfe2c8 100644 --- a/internal/fourbyte/funcs.go +++ b/internal/fourbyte/funcs.go @@ -4,6 +4,7 @@ package fourbyte import "github.com/lmittmann/w3" var functions = map[[4]byte]*w3.Func{ + {0x01, 0x66, 0x4f, 0x66}: w3.MustNewFunc("gemJoin()", "address"), {0x01, 0xe3, 0x36, 0x67}: w3.MustNewFunc("withdrawToken(address token, address to, uint256 amount)", ""), {0x01, 0xec, 0x95, 0x4a}: w3.MustNewFunc("onSwap((uint8 kind, address tokenIn, address tokenOut, uint256 amount, bytes32 poolId, uint256 lastChangeBlock, address from, address to, bytes userData) swapRequest, uint256[] balances, uint256 indexIn, uint256 indexOut)", "uint256 amount"), {0x01, 0xff, 0xc9, 0xa7}: w3.MustNewFunc("supportsInterface(bytes4)", "bool"), @@ -12,22 +13,26 @@ var functions = map[[4]byte]*w3.Func{ {0x02, 0xcc, 0x25, 0x0d}: w3.MustNewFunc("isSolver(address)", "bool"), {0x05, 0x4d, 0x50, 0xd4}: w3.MustNewFunc("getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut)", "uint256 amountOut"), {0x05, 0x8a, 0x62, 0x8f}: w3.MustNewFunc("setAuthorizer(address newAuthorizer)", ""), + {0x06, 0x7d, 0x92, 0x74}: w3.MustNewFunc("buyGemNoFee(address usr, uint256 gemAmt)", "uint256 daiInWad"), {0x06, 0xfd, 0xde, 0x03}: w3.MustNewFunc("name()", "string"), {0x07, 0x21, 0x1e, 0xf7}: w3.MustNewFunc("get_dy_underlying(int128 i, int128 j, uint256 amount)", "uint256"), {0x08, 0x18, 0x12, 0xfc}: w3.MustNewFunc("getApproved(uint256 tokenId)", "address operator"), {0x08, 0xc3, 0x79, 0xa0}: w3.MustNewFunc("Error(string)", ""), {0x09, 0x02, 0xf1, 0xac}: w3.MustNewFunc("getReserves()", "uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast"), {0x09, 0x5e, 0xa7, 0xb3}: w3.MustNewFunc("approve(address spender, uint256 amount)", "bool success"), + {0x0b, 0x0d, 0x9c, 0x09}: w3.MustNewFunc("take(address currency, address to, uint256 amount)", ""), {0x0c, 0x03, 0x3b, 0x9b}: w3.MustNewFunc("swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, uint256 amountLimit, uint256 deadline, bytes data)", "int256 amount0, int256 amount1"), {0x0d, 0x58, 0xb1, 0xdb}: w3.MustNewFunc("transferFrom((address from, address to, uint160 amount, address token)[] transferDetails)", ""), {0x0d, 0xfe, 0x16, 0x81}: w3.MustNewFunc("token0()", "address"), {0x0f, 0x5a, 0x6e, 0xfa}: w3.MustNewFunc("getInternalBalance(address user, address[] tokens)", "uint256[]"), + {0x11, 0xda, 0x60, 0xb4}: w3.MustNewFunc("settle()", "uint256 paid"), {0x12, 0x31, 0xae, 0x40}: w3.MustNewFunc("ETHNotAccepted()", ""), {0x12, 0x49, 0xc5, 0x8b}: w3.MustNewFunc("mint()", ""), {0x12, 0x8a, 0xcb, 0x08}: w3.MustNewFunc("swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, bytes data)", "int256 amount0, int256 amount1"), {0x13, 0xd7, 0x9a, 0x0b}: w3.MustNewFunc("settle(address[] tokens, uint256[] clearingPrices, (uint256 sellTokenIndex, uint256 buyTokenIndex, address receiver, uint256 sellAmount, uint256 buyAmount, uint32 validTo, bytes32 appData, uint256 feeAmount, uint256 flags, uint256 executedAmount, bytes signature)[] trades, (address target, uint256 value, bytes callData)[][3] interactions)", ""), {0x14, 0xe7, 0xa7, 0xab}: w3.MustNewFunc("settleAggregate((uint256 expiry, address takerAddress, address[] makerAddresses, uint256[] makerNonces, address[][] takerTokens, address[][] makerTokens, uint256[][] takerAmounts, uint256[][] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags)[] makersSignatures, uint256 filledTakerAmount, (bool useOldAmount, uint256[][] makerAmounts, uint256[] makerNonces) takerQuoteInfo, bytes takerSignature)", ""), {0x15, 0x0b, 0x7a, 0x02}: w3.MustNewFunc("onERC721Received(address operator, address from, uint256 tokenId, bytes data)", "bytes4"), + {0x15, 0x6e, 0x29, 0xf6}: w3.MustNewFunc("mint(address to, uint256 id, uint256 amount)", ""), {0x16, 0x26, 0xba, 0x7e}: w3.MustNewFunc("isValidSignature(bytes32 hash, bytes data)", "bytes4 magic"), {0x17, 0x32, 0x60, 0xeb}: w3.MustNewFunc("settleInternal((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (uint256[] increasedBuyAmounts, uint16 curFillPercent) makerData)", ""), {0x17, 0x7e, 0x80, 0x2f}: w3.MustNewFunc("ERC721InsufficientApproval(address operator, uint256 tokenId)", ""), @@ -38,23 +43,29 @@ var functions = map[[4]byte]*w3.Func{ {0x1a, 0x68, 0x65, 0x02}: w3.MustNewFunc("liquidity()", "uint128"), {0x1b, 0x9a, 0x91, 0xa4}: w3.MustNewFunc("withdrawEth(address to, uint256 amount)", ""), {0x1c, 0x56, 0x03, 0x05}: w3.MustNewFunc("claimMintRewardAndShare(address other, uint256 pct)", ""), + {0x1e, 0x2e, 0xae, 0xaf}: w3.MustNewFunc("extsload(bytes32 slot)", "bytes32 value"), {0x1f, 0x00, 0xca, 0x74}: w3.MustNewFunc("getAmountsIn(uint256 amountOut, address[] path)", "uint256[] amounts"), {0x20, 0xdb, 0x82, 0x67}: w3.MustNewFunc("InvalidPath()", ""), {0x21, 0x4a, 0x6f, 0xe2}: w3.MustNewFunc("accumulateReward(uint32 currTimestamp)", ""), {0x21, 0x95, 0x99, 0x5c}: w3.MustNewFunc("removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s)", "uint256 amountA, uint256 amountB"), + {0x21, 0xd0, 0xee, 0x70}: w3.MustNewFunc("beforeRemoveLiquidity(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, bytes hookData)", "bytes4"), + {0x23, 0x42, 0x66, 0xd7}: w3.MustNewFunc("donate((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint256 amount0, uint256 amount1, bytes hookData)", "int256 delta"), {0x23, 0xa6, 0x9e, 0x75}: w3.MustNewFunc("pancakeV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes data)", ""), {0x23, 0xb8, 0x72, 0xdd}: w3.MustNewFunc("transferFrom(address from, address to, uint256 amount)", "bool success"), {0x24, 0x85, 0x6b, 0xc3}: w3.MustNewFunc("execute(bytes commands, bytes[] inputs)", ""), {0x24, 0x8a, 0x9c, 0xa3}: w3.MustNewFunc("getRoleAdmin(bytes32 role)", "bytes32"), + {0x25, 0x99, 0x82, 0xe5}: w3.MustNewFunc("beforeAddLiquidity(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, bytes hookData)", "bytes4"), {0x28, 0xb2, 0xa7, 0x96}: w3.MustNewFunc("settleInternalWithPermitsSignatures((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, (bytes[] permitSignatures, bytes signatureBytesPermit2, uint48[] noncesPermit2, uint48 deadline) takerPermitsInfo, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (uint256[] increasedBuyAmounts, uint16 curFillPercent) makerData)", ""), {0x2a, 0x2d, 0x80, 0xd1}: w3.MustNewFunc("permit(address owner, ((address token, uint160 amount, uint48 expiration, uint48 nonce)[] details, address spender, uint256 sigDeadline) permitBatch, bytes signature)", ""), {0x2c, 0x40, 0x29, 0xe9}: w3.MustNewFunc("ExecutionFailed(uint256 commandIndex, bytes message)", ""), + {0x2d, 0x77, 0x13, 0x89}: w3.MustNewFunc("setProtocolFeeController(address controller)", ""), {0x2e, 0x1a, 0x7d, 0x4d}: w3.MustNewFunc("withdraw(uint256)", ""), {0x2f, 0x2f, 0xf1, 0x5d}: w3.MustNewFunc("grantRole(bytes32 role, address account)", ""), {0x31, 0x3c, 0xe5, 0x67}: w3.MustNewFunc("decimals()", "uint8"), {0x31, 0x6c, 0xf0, 0xeb}: w3.MustNewFunc("V3InvalidSwap()", ""), {0x32, 0xb1, 0x3d, 0x91}: w3.MustNewFunc("V3InvalidCaller()", ""), {0x35, 0x93, 0x56, 0x4c}: w3.MustNewFunc("execute(bytes commands, bytes[] inputs, uint256 deadline)", ""), + {0x35, 0xfd, 0x63, 0x1a}: w3.MustNewFunc("extsload(bytes32 startSlot, uint256 nSlots)", "bytes32[] values"), {0x36, 0x44, 0xe5, 0x15}: w3.MustNewFunc("DOMAIN_SEPARATOR()", "bytes32"), {0x36, 0x56, 0x8a, 0xbe}: w3.MustNewFunc("renounceRole(bytes32 role, address account)", ""), {0x36, 0xc7, 0x85, 0x16}: w3.MustNewFunc("transferFrom(address from, address to, uint160 amount, address token)", ""), @@ -69,9 +80,11 @@ var functions = map[[4]byte]*w3.Func{ {0x3a, 0x98, 0xef, 0x39}: w3.MustNewFunc("totalShares()", "uint256"), {0x3b, 0x99, 0xb5, 0x3d}: w3.MustNewFunc("SliceOutOfBounds()", ""), {0x3c, 0x2b, 0x9a, 0x7d}: w3.MustNewFunc("fillQuoteEthToToken(address buyTokenAddress, address target, bytes swapCallData, uint256 feeAmount)", ""), + {0x3d, 0xd4, 0x5a, 0xdb}: w3.MustNewFunc("settleFor(address recipient)", "uint256 paid"), {0x3d, 0xf0, 0x21, 0x24}: w3.MustNewFunc("exchange(int128 i, int128 j, uint256 dx, uint256 min_dy)", ""), {0x3f, 0x44, 0x28, 0x64}: w3.MustNewFunc("swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, uint256 amountLimit, uint256 deadline, bytes data, uint256 trackingCode)", "int256 amount0, int256 amount1"), {0x40, 0xc1, 0x0f, 0x19}: w3.MustNewFunc("mint(address to, uint256 amount)", ""), + {0x40, 0xd9, 0xc0, 0xe3}: w3.MustNewFunc("trim()", "uint256 wad"), {0x40, 0xfb, 0x07, 0xa0}: w3.MustNewFunc("buyAsset(uint256 minAmount, address receiver)", "uint256, uint256"), {0x42, 0x84, 0x2e, 0x0e}: w3.MustNewFunc("safeTransferFrom(address from, address to, uint256 tokenId)", ""), {0x42, 0x96, 0x6c, 0x68}: w3.MustNewFunc("burn(uint256)", ""), @@ -82,6 +95,7 @@ var functions = map[[4]byte]*w3.Func{ {0x47, 0xaa, 0xf0, 0x7a}: w3.MustNewFunc("SliceOverflow()", ""), {0x48, 0x3a, 0x69, 0x29}: w3.MustNewFunc("InvalidOwnerERC1155()", ""), {0x48, 0x5c, 0xc9, 0x55}: w3.MustNewFunc("initialize(address token0, address token1)", ""), + {0x48, 0xc8, 0x94, 0x91}: w3.MustNewFunc("unlock(bytes data)", "bytes"), {0x49, 0x0e, 0x6c, 0xbc}: w3.MustNewFunc("flash(address recipient, uint256 amount0, uint256 amount1, bytes data)", ""), {0x49, 0x3f, 0x4f, 0x74}: w3.MustNewFunc("get_address(uint256 idx)", "address"), {0x4a, 0x25, 0xd9, 0x4a}: w3.MustNewFunc("swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] path, address to, uint256 deadline)", "uint256[] amounts"), @@ -89,15 +103,18 @@ var functions = map[[4]byte]*w3.Func{ {0x4c, 0x84, 0xc1, 0xc8}: w3.MustNewFunc("wrapAll()", ""), {0x4d, 0xce, 0xbc, 0xba}: w3.MustNewFunc("swapSingle((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount)", ""), {0x4e, 0x48, 0x7b, 0x71}: w3.MustNewFunc("Panic(uint256)", ""), + {0x52, 0x75, 0x96, 0x51}: w3.MustNewFunc("updateDynamicLPFee((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint24 newDynamicLPFee)", ""), {0x52, 0xbb, 0xbe, 0x29}: w3.MustNewFunc("swap((bytes32 poolId, uint8 swapKind, address assetIn, address assetOut, uint256 amount, bytes data) singleSwap, (address sender, bool fromInternalBalance, address recipient, bool toInternalBalance) funds, uint256 limit, uint256 deadline)", "uint256"), {0x52, 0xc7, 0xf8, 0xdc}: w3.MustNewFunc("claimMintReward()", ""), {0x54, 0x0d, 0x49, 0x18}: w3.MustNewFunc("lmPool()", "address"), {0x54, 0xfd, 0x4d, 0x50}: w3.MustNewFunc("version()", "uint256"), {0x55, 0xe4, 0xb7, 0xbe}: w3.MustNewFunc("fillQuoteTokenToToken(address sellTokenAddress, address buyTokenAddress, address target, bytes swapCallData, uint256 sellAmount, uint256 feeAmount)", ""), {0x57, 0x4f, 0x2b, 0xa3}: w3.MustNewFunc("allPairsLength()", "uint256"), + {0x57, 0x5e, 0x24, 0xb4}: w3.MustNewFunc("beforeSwap(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96) params, bytes hookData)", "bytes4, int256, uint24"), {0x59, 0x09, 0xc0, 0xd5}: w3.MustNewFunc("price0CumulativeLast()", "uint256"), {0x59, 0x21, 0xc8, 0xe0}: w3.MustNewFunc("burnAfterSeize(uint256 amount)", "uint256"), {0x5a, 0x3d, 0x54, 0x93}: w3.MustNewFunc("price1CumulativeLast()", "uint256"), + {0x5a, 0x6b, 0xcf, 0xda}: w3.MustNewFunc("modifyLiquidity((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, bytes hookData)", "int256 callerDelta, int256 feesAccrued"), {0x5b, 0x08, 0xba, 0x18}: w3.MustNewFunc("ERC721InvalidOperator(address operator)", ""), {0x5b, 0x0d, 0x59, 0x84}: w3.MustNewFunc("removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s)", "uint256 amountETH"), {0x5b, 0x41, 0xb9, 0x08}: w3.MustNewFunc("exchange(uint256 i, uint256 j, uint256 dx, uint256 min_dy)", ""), @@ -110,6 +127,7 @@ var functions = map[[4]byte]*w3.Func{ {0x5e, 0x0d, 0x44, 0x3f}: w3.MustNewFunc("get_dy(int128 i, int128 j, uint256 amount)", "uint256"), {0x60, 0x29, 0x26, 0xbf}: w3.MustNewFunc("swapMulti((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address[] takerTokens, address[] makerTokens, uint256[] takerAmounts, uint256[] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount)", ""), {0x60, 0x52, 0x97, 0xe1}: w3.MustNewFunc("seize()", "uint256"), + {0x62, 0x76, 0xcb, 0xbe}: w3.MustNewFunc("initialize((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint160 sqrtPriceX96)", "int24 tick"), {0x63, 0x52, 0x21, 0x1e}: w3.MustNewFunc("ownerOf(uint256 tokenId)", "address"), {0x64, 0x28, 0x3d, 0x7b}: w3.MustNewFunc("ERC721IncorrectOwner(address sender, uint256 tokenId, address owner)", ""), {0x64, 0xa0, 0xae, 0x92}: w3.MustNewFunc("ERC721InvalidReceiver(address receiver)", ""), @@ -117,8 +135,10 @@ var functions = map[[4]byte]*w3.Func{ {0x67, 0x5c, 0xae, 0x38}: w3.MustNewFunc("InsufficientToken()", ""), {0x69, 0x62, 0xf8, 0x45}: w3.MustNewFunc("mint_relative(address to, uint256 frac)", "uint256"), {0x6a, 0x12, 0xf1, 0x04}: w3.MustNewFunc("InsufficientETH()", ""), + {0x6c, 0x2b, 0xbe, 0x7e}: w3.MustNewFunc("afterRemoveLiquidity(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, int256 delta, int256 feesAccrued, bytes hookData)", "bytes4, int256"), {0x6d, 0x54, 0x33, 0xe6}: w3.MustNewFunc("max(uint256, uint256)", "uint256"), {0x6f, 0x5f, 0xfb, 0x7e}: w3.MustNewFunc("ContractLocked()", ""), + {0x6f, 0xe7, 0xe6, 0xeb}: w3.MustNewFunc("afterInitialize(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint160 sqrtPriceX96, int24 tick)", "bytes4"), {0x70, 0xa0, 0x82, 0x31}: w3.MustNewFunc("balanceOf(address)", "uint256"), {0x71, 0x50, 0x18, 0xa6}: w3.MustNewFunc("renounceOwnership()", ""), {0x72, 0x84, 0xe4, 0x16}: w3.MustNewFunc("description()", "string"), @@ -140,7 +160,10 @@ var functions = map[[4]byte]*w3.Func{ {0x7d, 0x52, 0x99, 0x19}: w3.MustNewFunc("UnableToClaim()", ""), {0x7d, 0xbe, 0x7e, 0x89}: w3.MustNewFunc("InvalidOwnerERC721()", ""), {0x7e, 0x27, 0x32, 0x89}: w3.MustNewFunc("ERC721NonexistentToken(uint256 tokenId)", ""), + {0x7e, 0x87, 0xce, 0x7d}: w3.MustNewFunc("setProtocolFee((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint24 newProtocolFee)", ""), {0x7f, 0xf3, 0x6a, 0xb5}: w3.MustNewFunc("swapExactETHForTokens(uint256 amountOutMin, address[] path, address to, uint256 deadline)", "uint256[] amounts"), + {0x80, 0xf0, 0xb4, 0x4c}: w3.MustNewFunc("clear(address currency, uint256 amount)", ""), + {0x81, 0x61, 0xb8, 0x74}: w3.MustNewFunc("collectProtocolFees(address recipient, address currency, uint256 amount)", "uint256 amountCollected"), {0x81, 0xd1, 0x8d, 0x87}: w3.MustNewFunc("wad_exp(int256 power)", "uint256"), {0x82, 0x5c, 0xab, 0xa1}: w3.MustNewFunc("cancelOrderRFQ(uint256 orderInfo)", ""), {0x83, 0xc4, 0xa1, 0x9d}: w3.MustNewFunc("swapTargets(address)", "bool"), @@ -149,8 +172,10 @@ var functions = map[[4]byte]*w3.Func{ {0x85, 0xf8, 0xc2, 0x59}: w3.MustNewFunc("getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut)", "uint256 amountIn"), {0x87, 0x52, 0x8f, 0x13}: w3.MustNewFunc("settle((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, (bool result, address to, uint256 value, bytes data)[] interactions, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (address balanceRecipient, uint16 curFillPercent) solverData)", ""), {0x88, 0x03, 0xdb, 0xee}: w3.MustNewFunc("swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] path, address to, uint256 deadline)", "uint256[] amounts"), + {0x88, 0x1e, 0xb1, 0x4e}: w3.MustNewFunc("gush()", "uint256 wad"), {0x89, 0xc6, 0x2b, 0x64}: w3.MustNewFunc("ERC721InvalidOwner(address owner)", ""), {0x8a, 0xb0, 0xbc, 0x16}: w3.MustNewFunc("V2TooMuchRequested()", ""), + {0x8d, 0x7e, 0xf9, 0xbb}: w3.MustNewFunc("buyGem(address usr, uint256 gemAmt)", "uint256 daiInWad"), {0x8d, 0xa5, 0xcb, 0x5b}: w3.MustNewFunc("owner()", "address"), {0x90, 0x10, 0xd0, 0x7c}: w3.MustNewFunc("getRoleMember(bytes32 role, uint256 index)", "address"), {0x90, 0x93, 0xbf, 0x7b}: w3.MustNewFunc("settleAggregateAndSignPermit((uint256 expiry, address takerAddress, address[] makerAddresses, uint256[] makerNonces, address[][] takerTokens, address[][] makerTokens, uint256[][] takerAmounts, uint256[][] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags)[] makersSignatures, uint256 filledTakerAmount, (bool useOldAmount, uint256[][] makerAmounts, uint256[] makerNonces) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint256 deadline) takerPermitSignature)", ""), @@ -159,14 +184,19 @@ var functions = map[[4]byte]*w3.Func{ {0x94, 0x28, 0x0d, 0x62}: w3.MustNewFunc("ERC20InvalidSpender(address spender)", ""), {0x94, 0x5b, 0xce, 0xc9}: w3.MustNewFunc("batchSwap(uint8 swapKind, (bytes32 poolId, uint256 assetInIndex, uint256 assetOutIndex, uint256 amount, bytes data)[] swaps, address[] assets, (address sender, bool fromInternalBalance, address recipient, bool toInternalBalance) funds, int256[] limits, uint256 deadline)", "int256[]"), {0x95, 0x4c, 0x1c, 0x0d}: w3.MustNewFunc("buyAssetWithSig(address originator, uint256 minAmount, address receiver, uint256 deadline, bytes signature)", "uint256, uint256"), + {0x95, 0x7a, 0xa5, 0x8c}: w3.MustNewFunc("live()", "uint256"), {0x95, 0x9d, 0x6d, 0x29}: w3.MustNewFunc("getSellFee(uint256 grossAmount)", "uint256"), {0x95, 0xd8, 0x9b, 0x41}: w3.MustNewFunc("symbol()", "string"), {0x96, 0xc6, 0xfd, 0x1e}: w3.MustNewFunc("ERC20InvalidSender(address sender)", ""), {0x97, 0xbb, 0xda, 0x0e}: w3.MustNewFunc("updateSwapTargets(address target, bool add)", ""), + {0x97, 0xe8, 0xcd, 0x4e}: w3.MustNewFunc("protocolFeesAccrued(address currency)", "uint256 amount"), {0x99, 0x9b, 0x64, 0x64}: w3.MustNewFunc("fillQuoteTokenToEth(address sellTokenAddress, address target, bytes swapCallData, uint256 sellAmount, uint256 feePercentageBasisPoints)", ""), {0x9a, 0x6f, 0xc8, 0xf5}: w3.MustNewFunc("getRoundData(uint80 roundId)", "uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound"), + {0x9b, 0x65, 0x2d, 0xf6}: w3.MustNewFunc("chug()", "uint256 wad"), {0x9b, 0xe2, 0xa8, 0x84}: w3.MustNewFunc("canPerform(bytes32 actionId, address account, address where)", "bool"), + {0x9b, 0xf6, 0x64, 0x5f}: w3.MustNewFunc("exttload(bytes32[] slots)", "bytes32[] values"), {0x9d, 0xc2, 0x9f, 0xac}: w3.MustNewFunc("burn(address user, uint256 amount)", ""), + {0x9f, 0x06, 0x3e, 0xfc}: w3.MustNewFunc("afterAddLiquidity(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, int256 delta, int256 feesAccrued, bytes hookData)", "bytes4, int256"), {0xa0, 0x71, 0x2d, 0x68}: w3.MustNewFunc("mint(uint256)", ""), {0xa1, 0x6f, 0x5f, 0xd2}: w3.MustNewFunc("cumulativeSum()", "uint256"), {0xa2, 0x2c, 0xb4, 0x65}: w3.MustNewFunc("setApprovalForAll(address operator, bool approved)", ""), @@ -176,6 +206,7 @@ var functions = map[[4]byte]*w3.Func{ {0xa4, 0x57, 0xc2, 0xd7}: w3.MustNewFunc("decreaseAllowance(address spender, uint256 subtractedValue)", "bool success"), {0xa4, 0x98, 0x46, 0x33}: w3.MustNewFunc("crossLmTick(int24 tick, bool zeroForOne)", ""), {0xa4, 0xa2, 0x1f, 0xa2}: w3.MustNewFunc("getGrossAmountFromTotalBought(uint256 totalAmount)", "uint256"), + {0xa5, 0x84, 0x11, 0x94}: w3.MustNewFunc("sync(address currency)", ""), {0xa6, 0x41, 0x7e, 0xd6}: w3.MustNewFunc("exchange_underlying(int128 i, int128 j, uint256 dx, uint256 min_dy)", ""), {0xa7, 0x8a, 0xa2, 0x7f}: w3.MustNewFunc("ToAddressOutOfBounds()", ""), {0xa7, 0xb7, 0x8c, 0x3c}: w3.MustNewFunc("getAssetPriceInGho(uint256 assetAmount, bool roundUp)", "uint256"), @@ -191,6 +222,9 @@ var functions = map[[4]byte]*w3.Func{ {0xb0, 0x34, 0x43, 0x04}: w3.MustNewFunc("swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, bytes data, uint256 trackingCode)", "int256 amount0, int256 amount1"), {0xb0, 0x48, 0x0b, 0xbd}: w3.MustNewFunc("fillQuoteTokenToTokenWithPermit(address sellTokenAddress, address buyTokenAddress, address target, bytes swapCallData, uint256 sellAmount, uint256 feeAmount, (uint256 value, uint256 nonce, uint256 deadline, bool isDaiStylePermit, uint8 v, bytes32 r, bytes32 s) permitData)", ""), {0xb3, 0x09, 0x38, 0x38}: w3.MustNewFunc("fillQuoteTokenToEthWithPermit(address sellTokenAddress, address target, bytes swapCallData, uint256 sellAmount, uint256 feePercentageBasisPoints, (uint256 value, uint256 nonce, uint256 deadline, bool isDaiStylePermit, uint8 v, bytes32 r, bytes32 s) permitData)", ""), + {0xb3, 0xbc, 0xfa, 0x82}: w3.MustNewFunc("dec()", "uint256"), + {0xb4, 0x7b, 0x2f, 0xb1}: w3.MustNewFunc("afterSwap(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96) params, int256 delta, bytes hookData)", "bytes4, int128"), + {0xb6, 0xa8, 0xb0, 0xfa}: w3.MustNewFunc("beforeDonate(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint256 amount0, uint256 amount1, bytes hookData)", "bytes4"), {0xb6, 0xf9, 0xde, 0x95}: w3.MustNewFunc("swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] path, address to, uint256 deadline)", ""), {0xb8, 0x8d, 0x4f, 0xde}: w3.MustNewFunc("safeTransferFrom(address from, address to, uint256 tokenId, bytes data)", ""), {0xba, 0x9a, 0x7a, 0x56}: w3.MustNewFunc("MINIMUM_LIQUIDITY()", "uint256"), @@ -208,6 +242,7 @@ var functions = map[[4]byte]*w3.Func{ {0xc9, 0xc6, 0x53, 0x96}: w3.MustNewFunc("createPair(address tokenA, address tokenB)", "address pair"), {0xca, 0x15, 0xc8, 0x73}: w3.MustNewFunc("getRoleMemberCount(bytes32 role)", "uint256"), {0xca, 0xb4, 0x6b, 0xc6}: w3.MustNewFunc("setSwapFreeze(bool enable)", ""), + {0xcb, 0xf0, 0xbf, 0xac}: w3.MustNewFunc("rush()", "uint256 wad"), {0xcc, 0x94, 0xa6, 0x3a}: w3.MustNewFunc("NoSlice()", ""), {0xce, 0x7d, 0x65, 0x03}: w3.MustNewFunc("exchange(uint256 i, uint256 j, uint256 dx, uint256 min_dy, bool use_eth, address receiver)", "uint256"), {0xce, 0xa9, 0xd2, 0x6f}: w3.MustNewFunc("rescueTokens(address token, address to, uint256 amount)", ""), @@ -221,16 +256,21 @@ var functions = map[[4]byte]*w3.Func{ {0xd5, 0x47, 0x74, 0x1f}: w3.MustNewFunc("revokeRole(bytes32 role, address account)", ""), {0xd7, 0x6a, 0x1e, 0x9e}: w3.MustNewFunc("InvalidCommandType(uint256 commandType)", ""), {0xd9, 0x09, 0x6a, 0x3e}: w3.MustNewFunc("ToUint24OutOfBounds()", ""), + {0xd9, 0xc5, 0x5c, 0xe1}: w3.MustNewFunc("fill()", "uint256 wad"), + {0xdb, 0xd0, 0x35, 0xff}: w3.MustNewFunc("extsload(bytes32[] slots)", "bytes32[] values"), + {0xdc, 0x98, 0x35, 0x4e}: w3.MustNewFunc("beforeInitialize(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint160 sqrtPriceX96)", "bytes4"), {0xdd, 0x62, 0xed, 0x3e}: w3.MustNewFunc("allowance(address owner, address spender)", "uint256"), {0xdd, 0xc1, 0xf5, 0x9d}: w3.MustNewFunc("exchange(int128 i, int128 j, uint256 dx, uint256 min_dy, address receiver)", ""), {0xdd, 0xca, 0x3f, 0x43}: w3.MustNewFunc("fee()", "uint24"), {0xde, 0x28, 0x73, 0x59}: w3.MustNewFunc("acl()", "address"), {0xde, 0xaa, 0x01, 0xe6}: w3.MustNewFunc("InvalidBips()", ""), {0xde, 0xd9, 0x38, 0x2a}: w3.MustNewFunc("removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s)", "uint256 amountToken, uint256 amountETH"), + {0xe1, 0xb4, 0xaf, 0x69}: w3.MustNewFunc("afterDonate(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint256 amount0, uint256 amount1, bytes hookData)", "bytes4"), {0xe4, 0x49, 0x02, 0x2e}: w3.MustNewFunc("uniswapV3Swap(uint256 amount, uint256 minReturn, uint256[] pools)", "uint256 returnAmount"), {0xe4, 0x50, 0xd3, 0x8c}: w3.MustNewFunc("ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed)", ""), {0xe6, 0x02, 0xdf, 0x05}: w3.MustNewFunc("ERC20InvalidApprover(address approver)", ""), {0xe6, 0xa4, 0x39, 0x05}: w3.MustNewFunc("getPair(address tokenA, address tokenB)", "address pair"), + {0xe6, 0xfd, 0x60, 0x4c}: w3.MustNewFunc("cut()", "uint256 wad"), {0xe7, 0x00, 0x28, 0x77}: w3.MustNewFunc("FromAddressIsNotOwner()", ""), {0xe8, 0xe3, 0x37, 0x00}: w3.MustNewFunc("addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline)", "uint256 amountA, uint256 amountB, uint256 liquidity"), {0xe9, 0x85, 0xe9, 0xc5}: w3.MustNewFunc("isApprovedForAll(address owner, address operator)", "bool"), @@ -239,11 +279,14 @@ var functions = map[[4]byte]*w3.Func{ {0xec, 0x98, 0x37, 0x76}: w3.MustNewFunc("settleWithPermitsSignatures((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, (bytes[] permitSignatures, bytes signatureBytesPermit2, uint48[] noncesPermit2, uint48 deadline) takerPermitsInfo, (bool result, address to, uint256 value, bytes data)[] interactions, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (address balanceRecipient, uint16 curFillPercent) solverData)", ""), {0xef, 0x7d, 0x27, 0xad}: w3.MustNewFunc("settleSingleAndSignPermit((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256 makerAmount, uint256 makerNonce) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint256 deadline) takerPermitSignature)", ""), {0xef, 0xe3, 0x4f, 0xe6}: w3.MustNewFunc("settleMulti((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address[] takerTokens, address[] makerTokens, uint256[] takerAmounts, uint256[] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256[] makerAmounts, uint256 makerNonce) takerQuoteInfo, bytes takerSignature)", ""), + {0xf0, 0x2d, 0xe3, 0xb2}: w3.MustNewFunc("protocolFeeController()", "address"), + {0xf1, 0x35, 0xba, 0xaa}: w3.MustNewFunc("exttload(bytes32 slot)", "bytes32 value"), {0xf2, 0xfd, 0xe3, 0x8b}: w3.MustNewFunc("transferOwnership(address newOwner)", ""), {0xf3, 0x05, 0x83, 0x99}: w3.MustNewFunc("feeGrowthGlobal0X128()", "uint256"), {0xf3, 0x05, 0xd7, 0x19}: w3.MustNewFunc("addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline)", "uint256 amountToken, uint256 amountETH, uint256 liquidity"), {0xf4, 0x2c, 0x56, 0xc2}: w3.MustNewFunc("cbrt(uint256 x)", "uint256"), {0xf4, 0x93, 0xca, 0x70}: w3.MustNewFunc("sellAssetWithSig(address originator, uint256 maxAmount, address receiver, uint256 deadline, bytes signature)", "uint256, uint256"), + {0xf5, 0x29, 0x8a, 0xca}: w3.MustNewFunc("burn(address from, uint256 id, uint256 amount)", ""), {0xf8, 0x51, 0xa4, 0x40}: w3.MustNewFunc("admin()", "address"), {0xfa, 0x18, 0x04, 0x2d}: w3.MustNewFunc("reduction_coefficient(uint256[3] x, uint256 fee_gamma)", "uint256"), {0xfa, 0x46, 0x1e, 0x33}: w3.MustNewFunc("uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes data)", ""), diff --git a/internal/fourbyte/funcs.txt b/internal/fourbyte/funcs.txt index 22f7211f..560b2835 100644 --- a/internal/fourbyte/funcs.txt +++ b/internal/fourbyte/funcs.txt @@ -3,34 +3,53 @@ acl() address addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) uint256 amountA, uint256 amountB, uint256 liquidity addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) uint256 amountToken, uint256 amountETH, uint256 liquidity admin() address +afterAddLiquidity(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, int256 delta, int256 feesAccrued, bytes hookData) bytes4, int256 +afterDonate(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint256 amount0, uint256 amount1, bytes hookData) bytes4 +afterInitialize(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint160 sqrtPriceX96, int24 tick) bytes4 +afterRemoveLiquidity(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, int256 delta, int256 feesAccrued, bytes hookData) bytes4, int256 +afterSwap(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96) params, int256 delta, bytes hookData) bytes4, int128 allowance(address owner, address spender) uint256 allowance(address user, address token, address spender) uint160 amount, uint48 expiration, uint48 nonce allPairsLength() uint256 approve(address spender, uint256 amount) bool success balanceOf(address) uint256 batchSwap(uint8 swapKind, (bytes32 poolId, uint256 assetInIndex, uint256 assetOutIndex, uint256 amount, bytes data)[] swaps, address[] assets, (address sender, bool fromInternalBalance, address recipient, bool toInternalBalance) funds, int256[] limits, uint256 deadline) int256[] +beforeAddLiquidity(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, bytes hookData) bytes4 +beforeDonate(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint256 amount0, uint256 amount1, bytes hookData) bytes4 +beforeInitialize(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint160 sqrtPriceX96) bytes4 +beforeRemoveLiquidity(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, bytes hookData) bytes4 +beforeSwap(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96) params, bytes hookData) bytes4, int256, uint24 +burn(address from, uint256 id, uint256 amount) burn(address user, uint256 amount) burn(uint256) burnAfterSeize(uint256 amount) uint256 burnFrom(address to, uint256 value) bool buyAsset(uint256 minAmount, address receiver) uint256, uint256 buyAssetWithSig(address originator, uint256 minAmount, address receiver, uint256 deadline, bytes signature) uint256, uint256 +buyGem(address usr, uint256 gemAmt) uint256 daiInWad +buyGemNoFee(address usr, uint256 gemAmt) uint256 daiInWad cancelOrderRFQ(uint256 orderInfo) canPerform(bytes32 actionId, address account, address where) bool cbrt(uint256 x) uint256 +chug() uint256 wad claimMintReward() claimMintRewardAndShare(address other, uint256 pct) claimMintRewardAndStake(uint256 pct, uint256 term) +clear(address currency, uint256 amount) coins(uint256 i) address +collectProtocolFees(address recipient, address currency, uint256 amount) uint256 amountCollected ContractLocked() createPair(address tokenA, address tokenB) address pair crossLmTick(int24 tick, bool zeroForOne) cumulativeSum() uint256 +cut() uint256 wad +dec() uint256 decimals() uint8 decreaseAllowance(address spender, uint256 subtractedValue) bool success deposit() description() string DOMAIN_SEPARATOR() bytes32 +donate((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint256 amount0, uint256 amount1, bytes hookData) int256 delta ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed) ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed) ERC20InvalidApprover(address approver) @@ -56,10 +75,16 @@ exchange_underlying(int128 i, int128 j, uint256 dx, uint256 min_dy) execute(bytes commands, bytes[] inputs) execute(bytes commands, bytes[] inputs, uint256 deadline) ExecutionFailed(uint256 commandIndex, bytes message) +extsload(bytes32 slot) bytes32 value +extsload(bytes32 startSlot, uint256 nSlots) bytes32[] values +extsload(bytes32[] slots) bytes32[] values +exttload(bytes32 slot) bytes32 value +exttload(bytes32[] slots) bytes32[] values factory() address fee() uint24 feeGrowthGlobal0X128() uint256 feeGrowthGlobal1X128() uint256 +fill() uint256 wad fillOrderRFQ((uint256 info, address makerAsset, address takerAsset, address maker, address allowedSender, uint256 makingAmount, uint256 takingAmount) order, bytes signature, uint256 makingAmount, uint256 takingAmount) fillOrderRFQTo((uint256 info, address makerAsset, address takerAsset, address maker, address allowedSender, uint256 makingAmount, uint256 takingAmount) order, bytes signature, uint256 makingAmount, uint256 takingAmount, address target) fillQuoteEthToToken(address buyTokenAddress, address target, bytes swapCallData, uint256 feeAmount) @@ -69,6 +94,7 @@ fillQuoteTokenToToken(address sellTokenAddress, address buyTokenAddress, address fillQuoteTokenToTokenWithPermit(address sellTokenAddress, address buyTokenAddress, address target, bytes swapCallData, uint256 sellAmount, uint256 feeAmount, (uint256 value, uint256 nonce, uint256 deadline, bool isDaiStylePermit, uint8 v, bytes32 r, bytes32 s) permitData) flash(address recipient, uint256 amount0, uint256 amount1, bytes data) FromAddressIsNotOwner() +gemJoin() address geometric_mean(uint256[3] x) uint256 get_address(uint256 idx) address get_dy(int128 i, int128 j, uint256 amount) uint256 @@ -97,11 +123,13 @@ getRoleMemberCount(bytes32 role) uint256 getRoundData(uint80 roundId) uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound getSellFee(uint256 grossAmount) uint256 grantRole(bytes32 role, address account) +gush() uint256 wad hasApprovedRelayer(address user, address relayer) bool hasPermission(address who, address where, bytes32 what, bytes how) bool hasRole(bytes32 role, address account) bool implementation() address increaseAllowance(address spender, uint256 addedValue) bool success +initialize((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint160 sqrtPriceX96) int24 tick initialize(address token0, address token1) InsufficientETH() InsufficientToken() @@ -117,14 +145,17 @@ isValidSignature(bytes32 hash, bytes data) bytes4 magic kLast() uint256 latestRoundData() uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound liquidity() uint128 +live() uint256 lmPool() address max(uint256, uint256) uint256 min(uint256, uint256) uint256 MINIMUM_LIQUIDITY() uint256 mint() mint(address to, uint256 amount) +mint(address to, uint256 id, uint256 amount) mint(uint256) mint_relative(address to, uint256 frac) uint256 +modifyLiquidity((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, bytes hookData) int256 callerDelta, int256 feesAccrued name() string newton_D(uint256 ANN, uint256 gamma, uint256[3] x_unsorted, uint256 K0_prev) uint256 NoSlice() @@ -139,6 +170,8 @@ permit(address owner, ((address token, uint160 amount, uint48 expiration, uint48 permit(address owner, address spender, uint256 amount, uint256 deadline, uint8 v, bytes32 r, bytes32 s) price0CumulativeLast() uint256 price1CumulativeLast() uint256 +protocolFeeController() address +protocolFeesAccrued(address currency) uint256 amount quote(uint256 amountA, uint256 reserveA, uint256 reserveB) uint256 amountB reduction_coefficient(uint256[3] x, uint256 fee_gamma) uint256 removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) uint256 amountA, uint256 amountB @@ -151,6 +184,7 @@ renounceOwnership() renounceRole(bytes32 role, address account) rescueTokens(address token, address to, uint256 amount) revokeRole(bytes32 role, address account) +rush() uint256 wad safeTransferFrom(address from, address to, uint256 tokenId) safeTransferFrom(address from, address to, uint256 tokenId, bytes data) seize() uint256 @@ -159,15 +193,19 @@ sellAssetWithSig(address originator, uint256 maxAmount, address receiver, uint25 setApp(bytes32 namespace, bytes32 appId, address app) setApprovalForAll(address operator, bool approved) setAuthorizer(address newAuthorizer) +setProtocolFee((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint24 newProtocolFee) +setProtocolFeeController(address controller) setRelayerApproval(address sender, address relayer, bool approved) setSwapFeePercentage(uint256) setSwapFreeze(bool enable) settle((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, (bool result, address to, uint256 value, bytes data)[] interactions, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (address balanceRecipient, uint16 curFillPercent) solverData) +settle() uint256 paid settle(address[] tokens, uint256[] clearingPrices, (uint256 sellTokenIndex, uint256 buyTokenIndex, address receiver, uint256 sellAmount, uint256 buyAmount, uint32 validTo, bytes32 appData, uint256 feeAmount, uint256 flags, uint256 executedAmount, bytes signature)[] trades, (address target, uint256 value, bytes callData)[][3] interactions) settleAggregate((uint256 expiry, address takerAddress, address[] makerAddresses, uint256[] makerNonces, address[][] takerTokens, address[][] makerTokens, uint256[][] takerAmounts, uint256[][] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags)[] makersSignatures, uint256 filledTakerAmount, (bool useOldAmount, uint256[][] makerAmounts, uint256[] makerNonces) takerQuoteInfo, bytes takerSignature) settleAggregateAndSignPermit((uint256 expiry, address takerAddress, address[] makerAddresses, uint256[] makerNonces, address[][] takerTokens, address[][] makerTokens, uint256[][] takerAmounts, uint256[][] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags)[] makersSignatures, uint256 filledTakerAmount, (bool useOldAmount, uint256[][] makerAmounts, uint256[] makerNonces) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint256 deadline) takerPermitSignature) settleAggregateAndSignPermit2((uint256 expiry, address takerAddress, address[] makerAddresses, uint256[] makerNonces, address[][] takerTokens, address[][] makerTokens, uint256[][] takerAmounts, uint256[][] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags)[] makersSignatures, uint256 filledTakerAmount, (bool useOldAmount, uint256[][] makerAmounts, uint256[] makerNonces) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint48 deadline, uint48[] nonces) infoPermit2) settleBatch((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers)[] orders, (uint8 type, bytes signatureBytes)[] signatures, (bytes[] permitSignatures, bytes signatureBytesPermit2, uint48[] noncesPermit2, uint48 deadline)[] takersPermitsInfo, (bool result, address to, uint256 value, bytes data)[] interactions, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle)[] hooks, (address balanceRecipient, uint16[] curFillPercents, bool[] takersPermitsUsage, bool transferExactAmounts) solverData) +settleFor(address recipient) uint256 paid settleInternal((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (uint256[] increasedBuyAmounts, uint16 curFillPercent) makerData) settleInternalWithPermitsSignatures((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, (bytes[] permitSignatures, bytes signatureBytesPermit2, uint48[] noncesPermit2, uint48 deadline) takerPermitsInfo, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (uint256[] increasedBuyAmounts, uint16 curFillPercent) makerData) settleMulti((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address[] takerTokens, address[] makerTokens, uint256[] takerAmounts, uint256[] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256[] makerAmounts, uint256 makerNonce) takerQuoteInfo, bytes takerSignature) @@ -209,6 +247,8 @@ swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] path, ad swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] path, address to, uint256 deadline) uint256[] amounts symbol() string sync() +sync(address currency) +take(address currency, address to, uint256 amount) tickSpacing() int24 ToAddressOutOfBounds() ToAddressOverflow() @@ -228,11 +268,14 @@ transferFrom(address from, address to, uint256 amount) bool success transferFromAccounts((address account, address token, uint256 amount, bytes32 balance)[]) transferOwnership(address newOwner) transferTokens((address from, address receiver, address[] tokens, uint256[] amounts, uint256[] nftIds, bytes tokenTransferTypes, uint16 fillPercent) transferData) +trim() uint256 wad UnableToClaim() uniswapV3Swap(uint256 amount, uint256 minReturn, uint256[] pools) uint256 returnAmount uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes data) +unlock(bytes data) bytes UnsafeCast() updatedAt() uint256 +updateDynamicLPFee((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint24 newDynamicLPFee) updateSwapTargets(address target, bool add) V2InvalidPath() V2TooLittleReceived() From 9cee5d54c42763abd09687be396e08a5a7af74b4 Mon Sep 17 00:00:00 2001 From: lmittmann Date: Tue, 1 Apr 2025 23:59:10 +0200 Subject: [PATCH 07/11] added funcs --- internal/fourbyte/funcs.go | 95 +++++++++++++++++++++++++++++++++++++ internal/fourbyte/funcs.txt | 95 +++++++++++++++++++++++++++++++++++++ 2 files changed, 190 insertions(+) diff --git a/internal/fourbyte/funcs.go b/internal/fourbyte/funcs.go index bdc5e77e..4eaa1d0b 100644 --- a/internal/fourbyte/funcs.go +++ b/internal/fourbyte/funcs.go @@ -4,59 +4,82 @@ package fourbyte import "github.com/lmittmann/w3" var functions = map[[4]byte]*w3.Func{ + {0x01, 0x66, 0x4f, 0x66}: w3.MustNewFunc("gemJoin()", "address"), + {0x01, 0xe1, 0xd1, 0x14}: w3.MustNewFunc("totalAssets()", "uint256 totalManagedAssets"), {0x01, 0xe3, 0x36, 0x67}: w3.MustNewFunc("withdrawToken(address token, address to, uint256 amount)", ""), + {0x01, 0xec, 0x95, 0x4a}: w3.MustNewFunc("onSwap((uint8 kind, address tokenIn, address tokenOut, uint256 amount, bytes32 poolId, uint256 lastChangeBlock, address from, address to, bytes userData) swapRequest, uint256[] balances, uint256 indexIn, uint256 indexOut)", "uint256 amount"), {0x01, 0xff, 0xc9, 0xa7}: w3.MustNewFunc("supportsInterface(bytes4)", "bool"), {0x02, 0x2c, 0x0d, 0x9f}: w3.MustNewFunc("swap(uint256 amount0Out, uint256 amount1Out, address to, bytes data)", ""), {0x02, 0x75, 0x1c, 0xec}: w3.MustNewFunc("removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline)", "uint256 amountToken, uint256 amountETH"), {0x02, 0xcc, 0x25, 0x0d}: w3.MustNewFunc("isSolver(address)", "bool"), {0x05, 0x4d, 0x50, 0xd4}: w3.MustNewFunc("getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut)", "uint256 amountOut"), {0x05, 0x8a, 0x62, 0x8f}: w3.MustNewFunc("setAuthorizer(address newAuthorizer)", ""), + {0x06, 0x7d, 0x92, 0x74}: w3.MustNewFunc("buyGemNoFee(address usr, uint256 gemAmt)", "uint256 daiInWad"), {0x06, 0xfd, 0xde, 0x03}: w3.MustNewFunc("name()", "string"), {0x07, 0x21, 0x1e, 0xf7}: w3.MustNewFunc("get_dy_underlying(int128 i, int128 j, uint256 amount)", "uint256"), + {0x07, 0xa2, 0xd1, 0x3a}: w3.MustNewFunc("convertToAssets(uint256 shares)", "uint256 assets"), {0x08, 0x18, 0x12, 0xfc}: w3.MustNewFunc("getApproved(uint256 tokenId)", "address operator"), {0x08, 0xc3, 0x79, 0xa0}: w3.MustNewFunc("Error(string)", ""), {0x09, 0x02, 0xf1, 0xac}: w3.MustNewFunc("getReserves()", "uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast"), {0x09, 0x5e, 0xa7, 0xb3}: w3.MustNewFunc("approve(address spender, uint256 amount)", "bool success"), + {0x0a, 0x28, 0xa4, 0x77}: w3.MustNewFunc("previewWithdraw(uint256 assets)", "uint256 shares"), + {0x0b, 0x0d, 0x9c, 0x09}: w3.MustNewFunc("take(address currency, address to, uint256 amount)", ""), {0x0c, 0x03, 0x3b, 0x9b}: w3.MustNewFunc("swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, uint256 amountLimit, uint256 deadline, bytes data)", "int256 amount0, int256 amount1"), {0x0d, 0x58, 0xb1, 0xdb}: w3.MustNewFunc("transferFrom((address from, address to, uint160 amount, address token)[] transferDetails)", ""), {0x0d, 0xfe, 0x16, 0x81}: w3.MustNewFunc("token0()", "address"), {0x0f, 0x5a, 0x6e, 0xfa}: w3.MustNewFunc("getInternalBalance(address user, address[] tokens)", "uint256[]"), + {0x0f, 0xc6, 0x3d, 0x10}: w3.MustNewFunc("tokenA()", "address"), + {0x11, 0xda, 0x60, 0xb4}: w3.MustNewFunc("settle()", "uint256 paid"), {0x12, 0x31, 0xae, 0x40}: w3.MustNewFunc("ETHNotAccepted()", ""), {0x12, 0x49, 0xc5, 0x8b}: w3.MustNewFunc("mint()", ""), {0x12, 0x8a, 0xcb, 0x08}: w3.MustNewFunc("swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, bytes data)", "int256 amount0, int256 amount1"), {0x13, 0xd7, 0x9a, 0x0b}: w3.MustNewFunc("settle(address[] tokens, uint256[] clearingPrices, (uint256 sellTokenIndex, uint256 buyTokenIndex, address receiver, uint256 sellAmount, uint256 buyAmount, uint32 validTo, bytes32 appData, uint256 feeAmount, uint256 flags, uint256 executedAmount, bytes signature)[] trades, (address target, uint256 value, bytes callData)[][3] interactions)", ""), + {0x14, 0xe7, 0xa7, 0xab}: w3.MustNewFunc("settleAggregate((uint256 expiry, address takerAddress, address[] makerAddresses, uint256[] makerNonces, address[][] takerTokens, address[][] makerTokens, uint256[][] takerAmounts, uint256[][] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags)[] makersSignatures, uint256 filledTakerAmount, (bool useOldAmount, uint256[][] makerAmounts, uint256[] makerNonces) takerQuoteInfo, bytes takerSignature)", ""), {0x15, 0x0b, 0x7a, 0x02}: w3.MustNewFunc("onERC721Received(address operator, address from, uint256 tokenId, bytes data)", "bytes4"), + {0x15, 0x6e, 0x29, 0xf6}: w3.MustNewFunc("mint(address to, uint256 id, uint256 amount)", ""), + {0x15, 0xda, 0xcb, 0xea}: w3.MustNewFunc("transferFrom(address token, address owner, address recipient, uint256 amount)", "bool"), {0x16, 0x26, 0xba, 0x7e}: w3.MustNewFunc("isValidSignature(bytes32 hash, bytes data)", "bytes4 magic"), {0x17, 0x32, 0x60, 0xeb}: w3.MustNewFunc("settleInternal((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (uint256[] increasedBuyAmounts, uint16 curFillPercent) makerData)", ""), {0x17, 0x7e, 0x80, 0x2f}: w3.MustNewFunc("ERC721InsufficientApproval(address operator, uint256 tokenId)", ""), {0x18, 0x16, 0x0d, 0xdd}: w3.MustNewFunc("totalSupply()", "uint256"), {0x18, 0xcb, 0xaf, 0xe5}: w3.MustNewFunc("swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline)", "uint256[] amounts"), {0x18, 0xfd, 0xd0, 0x6b}: w3.MustNewFunc("getGrossAmountFromTotalSold(uint256 totalAmount)", "uint256"), + {0x1a, 0x49, 0x90, 0x26}: w3.MustNewFunc("settleSingle((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256 makerAmount, uint256 makerNonce) takerQuoteInfo, bytes takerSignature)", ""), {0x1a, 0x68, 0x65, 0x02}: w3.MustNewFunc("liquidity()", "uint128"), {0x1b, 0x9a, 0x91, 0xa4}: w3.MustNewFunc("withdrawEth(address to, uint256 amount)", ""), {0x1c, 0x56, 0x03, 0x05}: w3.MustNewFunc("claimMintRewardAndShare(address other, uint256 pct)", ""), + {0x1e, 0x2e, 0xae, 0xaf}: w3.MustNewFunc("extsload(bytes32 slot)", "bytes32 value"), {0x1f, 0x00, 0xca, 0x74}: w3.MustNewFunc("getAmountsIn(uint256 amountOut, address[] path)", "uint256[] amounts"), {0x20, 0xdb, 0x82, 0x67}: w3.MustNewFunc("InvalidPath()", ""), {0x21, 0x4a, 0x6f, 0xe2}: w3.MustNewFunc("accumulateReward(uint32 currTimestamp)", ""), {0x21, 0x95, 0x99, 0x5c}: w3.MustNewFunc("removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s)", "uint256 amountA, uint256 amountB"), + {0x21, 0xd0, 0xee, 0x70}: w3.MustNewFunc("beforeRemoveLiquidity(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, bytes hookData)", "bytes4"), + {0x22, 0x13, 0xbc, 0x0b}: w3.MustNewFunc("exec(address operator, address token, uint256 amount, address target, bytes data)", "bytes result"), + {0x23, 0x42, 0x66, 0xd7}: w3.MustNewFunc("donate((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint256 amount0, uint256 amount1, bytes hookData)", "int256 delta"), {0x23, 0xa6, 0x9e, 0x75}: w3.MustNewFunc("pancakeV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes data)", ""), {0x23, 0xb8, 0x72, 0xdd}: w3.MustNewFunc("transferFrom(address from, address to, uint256 amount)", "bool success"), {0x24, 0x85, 0x6b, 0xc3}: w3.MustNewFunc("execute(bytes commands, bytes[] inputs)", ""), {0x24, 0x8a, 0x9c, 0xa3}: w3.MustNewFunc("getRoleAdmin(bytes32 role)", "bytes32"), + {0x25, 0x99, 0x82, 0xe5}: w3.MustNewFunc("beforeAddLiquidity(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, bytes hookData)", "bytes4"), {0x28, 0xb2, 0xa7, 0x96}: w3.MustNewFunc("settleInternalWithPermitsSignatures((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, (bytes[] permitSignatures, bytes signatureBytesPermit2, uint48[] noncesPermit2, uint48 deadline) takerPermitsInfo, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (uint256[] increasedBuyAmounts, uint16 curFillPercent) makerData)", ""), {0x2a, 0x2d, 0x80, 0xd1}: w3.MustNewFunc("permit(address owner, ((address token, uint160 amount, uint48 expiration, uint48 nonce)[] details, address spender, uint256 sigDeadline) permitBatch, bytes signature)", ""), {0x2c, 0x40, 0x29, 0xe9}: w3.MustNewFunc("ExecutionFailed(uint256 commandIndex, bytes message)", ""), + {0x2d, 0x77, 0x13, 0x89}: w3.MustNewFunc("setProtocolFeeController(address controller)", ""), {0x2e, 0x1a, 0x7d, 0x4d}: w3.MustNewFunc("withdraw(uint256)", ""), {0x2f, 0x2f, 0xf1, 0x5d}: w3.MustNewFunc("grantRole(bytes32 role, address account)", ""), {0x31, 0x3c, 0xe5, 0x67}: w3.MustNewFunc("decimals()", "uint8"), {0x31, 0x6c, 0xf0, 0xeb}: w3.MustNewFunc("V3InvalidSwap()", ""), {0x32, 0xb1, 0x3d, 0x91}: w3.MustNewFunc("V3InvalidCaller()", ""), {0x35, 0x93, 0x56, 0x4c}: w3.MustNewFunc("execute(bytes commands, bytes[] inputs, uint256 deadline)", ""), + {0x35, 0xfd, 0x63, 0x1a}: w3.MustNewFunc("extsload(bytes32 startSlot, uint256 nSlots)", "bytes32[] values"), {0x36, 0x44, 0xe5, 0x15}: w3.MustNewFunc("DOMAIN_SEPARATOR()", "bytes32"), {0x36, 0x56, 0x8a, 0xbe}: w3.MustNewFunc("renounceRole(bytes32 role, address account)", ""), {0x36, 0xc7, 0x85, 0x16}: w3.MustNewFunc("transferFrom(address from, address to, uint160 amount, address token)", ""), + {0x38, 0x4e, 0xad, 0xa0}: w3.MustNewFunc("settleMultiAndSignPermit((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address[] takerTokens, address[] makerTokens, uint256[] takerAmounts, uint256[] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256[] makerAmounts, uint256 makerNonce) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint256 deadline) takerPermitSignature)", ""), {0x38, 0x50, 0xc7, 0xbd}: w3.MustNewFunc("slot0()", "(uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint8 feeProtocol, bool unlocked)"), + {0x38, 0xd5, 0x2e, 0x0f}: w3.MustNewFunc("asset()", "address assetTokenAddress"), {0x38, 0xe9, 0x92, 0x2e}: w3.MustNewFunc("setSwapFeePercentage(uint256)", ""), + {0x38, 0xec, 0x02, 0x11}: w3.MustNewFunc("settleSingleAndSignPermit2((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256 makerAmount, uint256 makerNonce) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint48 deadline, uint48 nonce) takerPermit2Signature)", ""), {0x38, 0xed, 0x17, 0x39}: w3.MustNewFunc("swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline)", "uint256[] amounts"), {0x39, 0x47, 0x47, 0xc5}: w3.MustNewFunc("exchange(uint256 i, uint256 j, uint256 dx, uint256 min_dy, bool use_eth)", ""), {0x39, 0x50, 0x93, 0x51}: w3.MustNewFunc("increaseAllowance(address spender, uint256 addedValue)", "bool success"), @@ -64,10 +87,14 @@ var functions = map[[4]byte]*w3.Func{ {0x3a, 0x98, 0xef, 0x39}: w3.MustNewFunc("totalShares()", "uint256"), {0x3b, 0x99, 0xb5, 0x3d}: w3.MustNewFunc("SliceOutOfBounds()", ""), {0x3c, 0x2b, 0x9a, 0x7d}: w3.MustNewFunc("fillQuoteEthToToken(address buyTokenAddress, address target, bytes swapCallData, uint256 feeAmount)", ""), + {0x3d, 0xd4, 0x5a, 0xdb}: w3.MustNewFunc("settleFor(address recipient)", "uint256 paid"), {0x3d, 0xf0, 0x21, 0x24}: w3.MustNewFunc("exchange(int128 i, int128 j, uint256 dx, uint256 min_dy)", ""), {0x3f, 0x44, 0x28, 0x64}: w3.MustNewFunc("swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, uint256 amountLimit, uint256 deadline, bytes data, uint256 trackingCode)", "int256 amount0, int256 amount1"), + {0x40, 0x2d, 0x26, 0x7d}: w3.MustNewFunc("maxDeposit(address receiver)", "uint256 maxAssets"), {0x40, 0xc1, 0x0f, 0x19}: w3.MustNewFunc("mint(address to, uint256 amount)", ""), + {0x40, 0xd9, 0xc0, 0xe3}: w3.MustNewFunc("trim()", "uint256 wad"), {0x40, 0xfb, 0x07, 0xa0}: w3.MustNewFunc("buyAsset(uint256 minAmount, address receiver)", "uint256, uint256"), + {0x41, 0x4b, 0xf3, 0x89}: w3.MustNewFunc("exactInputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96) params)", "uint256 amountOut"), {0x42, 0x84, 0x2e, 0x0e}: w3.MustNewFunc("safeTransferFrom(address from, address to, uint256 tokenId)", ""), {0x42, 0x96, 0x6c, 0x68}: w3.MustNewFunc("burn(uint256)", ""), {0x45, 0xd6, 0x49, 0x4d}: w3.MustNewFunc("getBuyFee(uint256 grossAmount)", "uint256"), @@ -77,21 +104,28 @@ var functions = map[[4]byte]*w3.Func{ {0x47, 0xaa, 0xf0, 0x7a}: w3.MustNewFunc("SliceOverflow()", ""), {0x48, 0x3a, 0x69, 0x29}: w3.MustNewFunc("InvalidOwnerERC1155()", ""), {0x48, 0x5c, 0xc9, 0x55}: w3.MustNewFunc("initialize(address token0, address token1)", ""), + {0x48, 0xc8, 0x94, 0x91}: w3.MustNewFunc("unlock(bytes data)", "bytes"), {0x49, 0x0e, 0x6c, 0xbc}: w3.MustNewFunc("flash(address recipient, uint256 amount0, uint256 amount1, bytes data)", ""), {0x49, 0x3f, 0x4f, 0x74}: w3.MustNewFunc("get_address(uint256 idx)", "address"), + {0x4a, 0x24, 0x8d, 0x2a}: w3.MustNewFunc("_BASE_TOKEN_()", "address"), {0x4a, 0x25, 0xd9, 0x4a}: w3.MustNewFunc("swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] path, address to, uint256 deadline)", "uint256[] amounts"), {0x4a, 0x2a, 0xb3, 0xbe}: w3.MustNewFunc("get_y(uint256 ANN, uint256 gamma, uint256[3] x, uint256 D, uint256 i)", "uint256[2]"), {0x4c, 0x84, 0xc1, 0xc8}: w3.MustNewFunc("wrapAll()", ""), + {0x4c, 0xda, 0xd5, 0x06}: w3.MustNewFunc("previewRedeem(uint256 shares)", "uint256 assets"), + {0x4d, 0xce, 0xbc, 0xba}: w3.MustNewFunc("swapSingle((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount)", ""), {0x4e, 0x48, 0x7b, 0x71}: w3.MustNewFunc("Panic(uint256)", ""), + {0x52, 0x75, 0x96, 0x51}: w3.MustNewFunc("updateDynamicLPFee((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint24 newDynamicLPFee)", ""), {0x52, 0xbb, 0xbe, 0x29}: w3.MustNewFunc("swap((bytes32 poolId, uint8 swapKind, address assetIn, address assetOut, uint256 amount, bytes data) singleSwap, (address sender, bool fromInternalBalance, address recipient, bool toInternalBalance) funds, uint256 limit, uint256 deadline)", "uint256"), {0x52, 0xc7, 0xf8, 0xdc}: w3.MustNewFunc("claimMintReward()", ""), {0x54, 0x0d, 0x49, 0x18}: w3.MustNewFunc("lmPool()", "address"), {0x54, 0xfd, 0x4d, 0x50}: w3.MustNewFunc("version()", "uint256"), {0x55, 0xe4, 0xb7, 0xbe}: w3.MustNewFunc("fillQuoteTokenToToken(address sellTokenAddress, address buyTokenAddress, address target, bytes swapCallData, uint256 sellAmount, uint256 feeAmount)", ""), {0x57, 0x4f, 0x2b, 0xa3}: w3.MustNewFunc("allPairsLength()", "uint256"), + {0x57, 0x5e, 0x24, 0xb4}: w3.MustNewFunc("beforeSwap(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96) params, bytes hookData)", "bytes4, int256, uint24"), {0x59, 0x09, 0xc0, 0xd5}: w3.MustNewFunc("price0CumulativeLast()", "uint256"), {0x59, 0x21, 0xc8, 0xe0}: w3.MustNewFunc("burnAfterSeize(uint256 amount)", "uint256"), {0x5a, 0x3d, 0x54, 0x93}: w3.MustNewFunc("price1CumulativeLast()", "uint256"), + {0x5a, 0x6b, 0xcf, 0xda}: w3.MustNewFunc("modifyLiquidity((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, bytes hookData)", "int256 callerDelta, int256 feesAccrued"), {0x5b, 0x08, 0xba, 0x18}: w3.MustNewFunc("ERC721InvalidOperator(address operator)", ""), {0x5b, 0x0d, 0x59, 0x84}: w3.MustNewFunc("removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s)", "uint256 amountETH"), {0x5b, 0x41, 0xb9, 0x08}: w3.MustNewFunc("exchange(uint256 i, uint256 j, uint256 dx, uint256 min_dy)", ""), @@ -102,18 +136,30 @@ var functions = map[[4]byte]*w3.Func{ {0x5c, 0x97, 0x5a, 0xbb}: w3.MustNewFunc("paused()", "bool"), {0x5d, 0xed, 0x74, 0xa5}: w3.MustNewFunc("getGhoPriceInAsset(uint256 ghoAmount, bool roundUp)", "uint256"), {0x5e, 0x0d, 0x44, 0x3f}: w3.MustNewFunc("get_dy(int128 i, int128 j, uint256 amount)", "uint256"), + {0x5f, 0x64, 0xb5, 0x5b}: w3.MustNewFunc("tokenB()", "address"), + {0x60, 0x05, 0x38, 0xe7}: w3.MustNewFunc("fillRfqOrderSelfFunded(address recipient, (address token, uint256 amount, uint256 nonce, uint256 deadline) permitted, address maker, bytes makerSig, address takerToken, uint256 maxTakerAmount)", ""), + {0x60, 0x29, 0x26, 0xbf}: w3.MustNewFunc("swapMulti((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address[] takerTokens, address[] makerTokens, uint256[] takerAmounts, uint256[] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount)", ""), {0x60, 0x52, 0x97, 0xe1}: w3.MustNewFunc("seize()", "uint256"), + {0x62, 0x76, 0xcb, 0xbe}: w3.MustNewFunc("initialize((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint160 sqrtPriceX96)", "int24 tick"), {0x63, 0x52, 0x21, 0x1e}: w3.MustNewFunc("ownerOf(uint256 tokenId)", "address"), + {0x63, 0x70, 0xa8, 0x5c}: w3.MustNewFunc("curveTricryptoSwapCallback(address payer, address receiver, address sellToken, uint256 sellAmount, uint256 buyAmount)", ""), {0x64, 0x28, 0x3d, 0x7b}: w3.MustNewFunc("ERC721IncorrectOwner(address sender, uint256 tokenId, address owner)", ""), {0x64, 0xa0, 0xae, 0x92}: w3.MustNewFunc("ERC721InvalidReceiver(address receiver)", ""), + {0x66, 0xa6, 0x5e, 0x41}: w3.MustNewFunc("settleMultiAndSignPermit2((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address[] takerTokens, address[] makerTokens, uint256[] takerAmounts, uint256[] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256[] makerAmounts, uint256 makerNonce) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint48 deadline, uint48[] nonces) infoPermit2)", ""), + {0x67, 0x1c, 0x21, 0x15}: w3.MustNewFunc("fillRfqOrderVIP(address recipient, (address token, uint256 amount, uint256 nonce, uint256 deadline) makerPermit, address maker, bytes makerSig, (address token, uint256 amount, uint256 nonce, uint256 deadline) takerPermit, bytes takerSig)", ""), {0x67, 0x5c, 0xae, 0x38}: w3.MustNewFunc("InsufficientToken()", ""), + {0x67, 0xca, 0x7c, 0x91}: w3.MustNewFunc("maverickV2SwapCallback(address tokenIn, uint256 amountIn, uint256 amountOut, bytes data)", ""), {0x69, 0x62, 0xf8, 0x45}: w3.MustNewFunc("mint_relative(address to, uint256 frac)", "uint256"), {0x6a, 0x12, 0xf1, 0x04}: w3.MustNewFunc("InsufficientETH()", ""), + {0x6c, 0x2b, 0xbe, 0x7e}: w3.MustNewFunc("afterRemoveLiquidity(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, int256 delta, int256 feesAccrued, bytes hookData)", "bytes4, int256"), {0x6d, 0x54, 0x33, 0xe6}: w3.MustNewFunc("max(uint256, uint256)", "uint256"), + {0x6e, 0x55, 0x3f, 0x65}: w3.MustNewFunc("deposit(uint256 assets, address receiver)", "uint256 shares"), {0x6f, 0x5f, 0xfb, 0x7e}: w3.MustNewFunc("ContractLocked()", ""), + {0x6f, 0xe7, 0xe6, 0xeb}: w3.MustNewFunc("afterInitialize(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint160 sqrtPriceX96, int24 tick)", "bytes4"), {0x70, 0xa0, 0x82, 0x31}: w3.MustNewFunc("balanceOf(address)", "uint256"), {0x71, 0x50, 0x18, 0xa6}: w3.MustNewFunc("renounceOwnership()", ""), {0x72, 0x84, 0xe4, 0x16}: w3.MustNewFunc("description()", "string"), + {0x72, 0xfc, 0x32, 0xe5}: w3.MustNewFunc("settleAggregateAndSignPermit2((uint256 expiry, address takerAddress, address[] makerAddresses, uint256[] makerNonces, address[][] takerTokens, address[][] makerTokens, uint256[][] takerAmounts, uint256[][] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags)[] makersSignatures, uint256 filledTakerAmount, (bool useOldAmount, uint256[][] makerAmounts, uint256[] makerNonces) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint48 deadline, uint48[] nonces) infoPermit2)", ""), {0x73, 0x9d, 0xbe, 0x52}: w3.MustNewFunc("V3TooMuchRequested()", ""), {0x73, 0xc6, 0xac, 0x6e}: w3.MustNewFunc("ERC721InvalidSender(address sender)", ""), {0x74, 0x64, 0xfc, 0x3d}: w3.MustNewFunc("kLast()", "uint256"), @@ -131,39 +177,55 @@ var functions = map[[4]byte]*w3.Func{ {0x7d, 0x52, 0x99, 0x19}: w3.MustNewFunc("UnableToClaim()", ""), {0x7d, 0xbe, 0x7e, 0x89}: w3.MustNewFunc("InvalidOwnerERC721()", ""), {0x7e, 0x27, 0x32, 0x89}: w3.MustNewFunc("ERC721NonexistentToken(uint256 tokenId)", ""), + {0x7e, 0x87, 0xce, 0x7d}: w3.MustNewFunc("setProtocolFee((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint24 newProtocolFee)", ""), {0x7f, 0xf3, 0x6a, 0xb5}: w3.MustNewFunc("swapExactETHForTokens(uint256 amountOutMin, address[] path, address to, uint256 deadline)", "uint256[] amounts"), + {0x80, 0xf0, 0xb4, 0x4c}: w3.MustNewFunc("clear(address currency, uint256 amount)", ""), + {0x81, 0x61, 0xb8, 0x74}: w3.MustNewFunc("collectProtocolFees(address recipient, address currency, uint256 amount)", "uint256 amountCollected"), {0x81, 0xd1, 0x8d, 0x87}: w3.MustNewFunc("wad_exp(int256 power)", "uint256"), + {0x82, 0x5c, 0xab, 0xa1}: w3.MustNewFunc("cancelOrderRFQ(uint256 orderInfo)", ""), {0x83, 0xc4, 0xa1, 0x9d}: w3.MustNewFunc("swapTargets(address)", "bool"), {0x84, 0x9e, 0xaf, 0x98}: w3.MustNewFunc("V2TooLittleReceived()", ""), {0x85, 0x58, 0x59, 0xb4}: w3.MustNewFunc("ToUint24Overflow()", ""), {0x85, 0xf8, 0xc2, 0x59}: w3.MustNewFunc("getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut)", "uint256 amountIn"), {0x87, 0x52, 0x8f, 0x13}: w3.MustNewFunc("settle((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, (bool result, address to, uint256 value, bytes data)[] interactions, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (address balanceRecipient, uint16 curFillPercent) solverData)", ""), {0x88, 0x03, 0xdb, 0xee}: w3.MustNewFunc("swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] path, address to, uint256 deadline)", "uint256[] amounts"), + {0x88, 0x1e, 0xb1, 0x4e}: w3.MustNewFunc("gush()", "uint256 wad"), {0x89, 0xc6, 0x2b, 0x64}: w3.MustNewFunc("ERC721InvalidOwner(address owner)", ""), {0x8a, 0xb0, 0xbc, 0x16}: w3.MustNewFunc("V2TooMuchRequested()", ""), + {0x8d, 0x7e, 0xf9, 0xbb}: w3.MustNewFunc("buyGem(address usr, uint256 gemAmt)", "uint256 daiInWad"), {0x8d, 0xa5, 0xcb, 0x5b}: w3.MustNewFunc("owner()", "address"), {0x90, 0x10, 0xd0, 0x7c}: w3.MustNewFunc("getRoleMember(bytes32 role, uint256 index)", "address"), + {0x90, 0x93, 0xbf, 0x7b}: w3.MustNewFunc("settleAggregateAndSignPermit((uint256 expiry, address takerAddress, address[] makerAddresses, uint256[] makerNonces, address[][] takerTokens, address[][] makerTokens, uint256[][] takerAmounts, uint256[][] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags)[] makersSignatures, uint256 filledTakerAmount, (bool useOldAmount, uint256[][] makerAmounts, uint256[] makerNonces) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint256 deadline) takerPermitSignature)", ""), {0x91, 0xd1, 0x48, 0x54}: w3.MustNewFunc("hasRole(bytes32 role, address account)", "bool"), {0x92, 0x7d, 0xa1, 0x05}: w3.MustNewFunc("allowance(address user, address token, address spender)", "uint160 amount, uint48 expiration, uint48 nonce"), {0x94, 0x28, 0x0d, 0x62}: w3.MustNewFunc("ERC20InvalidSpender(address spender)", ""), {0x94, 0x5b, 0xce, 0xc9}: w3.MustNewFunc("batchSwap(uint8 swapKind, (bytes32 poolId, uint256 assetInIndex, uint256 assetOutIndex, uint256 amount, bytes data)[] swaps, address[] assets, (address sender, bool fromInternalBalance, address recipient, bool toInternalBalance) funds, int256[] limits, uint256 deadline)", "int256[]"), + {0x94, 0xbf, 0x80, 0x4d}: w3.MustNewFunc("mint(uint256 shares, address receiver)", "uint256 assets"), {0x95, 0x4c, 0x1c, 0x0d}: w3.MustNewFunc("buyAssetWithSig(address originator, uint256 minAmount, address receiver, uint256 deadline, bytes signature)", "uint256, uint256"), + {0x95, 0x7a, 0xa5, 0x8c}: w3.MustNewFunc("live()", "uint256"), + {0x95, 0x99, 0x12, 0x76}: w3.MustNewFunc("sellGem(address usr, uint256 gemAmt)", "uint256 daiOutWad"), {0x95, 0x9d, 0x6d, 0x29}: w3.MustNewFunc("getSellFee(uint256 grossAmount)", "uint256"), {0x95, 0xd8, 0x9b, 0x41}: w3.MustNewFunc("symbol()", "string"), {0x96, 0xc6, 0xfd, 0x1e}: w3.MustNewFunc("ERC20InvalidSender(address sender)", ""), {0x97, 0xbb, 0xda, 0x0e}: w3.MustNewFunc("updateSwapTargets(address target, bool add)", ""), + {0x97, 0xe8, 0xcd, 0x4e}: w3.MustNewFunc("protocolFeesAccrued(address currency)", "uint256 amount"), {0x99, 0x9b, 0x64, 0x64}: w3.MustNewFunc("fillQuoteTokenToEth(address sellTokenAddress, address target, bytes swapCallData, uint256 sellAmount, uint256 feePercentageBasisPoints)", ""), {0x9a, 0x6f, 0xc8, 0xf5}: w3.MustNewFunc("getRoundData(uint80 roundId)", "uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound"), + {0x9b, 0x65, 0x2d, 0xf6}: w3.MustNewFunc("chug()", "uint256 wad"), {0x9b, 0xe2, 0xa8, 0x84}: w3.MustNewFunc("canPerform(bytes32 actionId, address account, address where)", "bool"), + {0x9b, 0xf6, 0x64, 0x5f}: w3.MustNewFunc("exttload(bytes32[] slots)", "bytes32[] values"), {0x9d, 0xc2, 0x9f, 0xac}: w3.MustNewFunc("burn(address user, uint256 amount)", ""), + {0x9f, 0x06, 0x3e, 0xfc}: w3.MustNewFunc("afterAddLiquidity(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, int256 delta, int256 feesAccrued, bytes hookData)", "bytes4, int256"), {0xa0, 0x71, 0x2d, 0x68}: w3.MustNewFunc("mint(uint256)", ""), {0xa1, 0x6f, 0x5f, 0xd2}: w3.MustNewFunc("cumulativeSum()", "uint256"), {0xa2, 0x2c, 0xb4, 0x65}: w3.MustNewFunc("setApprovalForAll(address operator, bool approved)", ""), {0xa2, 0x3b, 0xa0, 0x9c}: w3.MustNewFunc("swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, uint256 amountLimit, uint256 deadline, uint256 trackingCode)", "int256 amount0, int256 amount1"), {0xa2, 0x62, 0x90, 0x4b}: w3.MustNewFunc("get_registry()", "address"), + {0xa2, 0xf7, 0x48, 0x93}: w3.MustNewFunc("swapAggregate((uint256 expiry, address takerAddress, address[] makerAddresses, uint256[] makerNonces, address[][] takerTokens, address[][] makerTokens, uint256[][] takerAmounts, uint256[][] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags)[] makersSignatures, uint256 filledTakerAmount)", ""), {0xa4, 0x57, 0xc2, 0xd7}: w3.MustNewFunc("decreaseAllowance(address spender, uint256 subtractedValue)", "bool success"), {0xa4, 0x98, 0x46, 0x33}: w3.MustNewFunc("crossLmTick(int24 tick, bool zeroForOne)", ""), {0xa4, 0xa2, 0x1f, 0xa2}: w3.MustNewFunc("getGrossAmountFromTotalBought(uint256 totalAmount)", "uint256"), + {0xa5, 0x84, 0x11, 0x94}: w3.MustNewFunc("sync(address currency)", ""), {0xa6, 0x41, 0x7e, 0xd6}: w3.MustNewFunc("exchange_underlying(int128 i, int128 j, uint256 dx, uint256 min_dy)", ""), {0xa7, 0x8a, 0xa2, 0x7f}: w3.MustNewFunc("ToAddressOutOfBounds()", ""), {0xa7, 0xb7, 0x8c, 0x3c}: w3.MustNewFunc("getAssetPriceInGho(uint256 assetAmount, bool roundUp)", "uint256"), @@ -179,58 +241,91 @@ var functions = map[[4]byte]*w3.Func{ {0xb0, 0x34, 0x43, 0x04}: w3.MustNewFunc("swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, bytes data, uint256 trackingCode)", "int256 amount0, int256 amount1"), {0xb0, 0x48, 0x0b, 0xbd}: w3.MustNewFunc("fillQuoteTokenToTokenWithPermit(address sellTokenAddress, address buyTokenAddress, address target, bytes swapCallData, uint256 sellAmount, uint256 feeAmount, (uint256 value, uint256 nonce, uint256 deadline, bool isDaiStylePermit, uint8 v, bytes32 r, bytes32 s) permitData)", ""), {0xb3, 0x09, 0x38, 0x38}: w3.MustNewFunc("fillQuoteTokenToEthWithPermit(address sellTokenAddress, address target, bytes swapCallData, uint256 sellAmount, uint256 feePercentageBasisPoints, (uint256 value, uint256 nonce, uint256 deadline, bool isDaiStylePermit, uint8 v, bytes32 r, bytes32 s) permitData)", ""), + {0xb3, 0xbc, 0xfa, 0x82}: w3.MustNewFunc("dec()", "uint256"), + {0xb3, 0xd7, 0xf6, 0xb9}: w3.MustNewFunc("previewMint(uint256 shares)", "uint256 assets"), + {0xb4, 0x60, 0xaf, 0x94}: w3.MustNewFunc("withdraw(uint256 assets, address receiver, address owner)", "uint256 shares"), + {0xb4, 0x7b, 0x2f, 0xb1}: w3.MustNewFunc("afterSwap(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96) params, int256 delta, bytes hookData)", "bytes4, int128"), + {0xb6, 0xa8, 0xb0, 0xfa}: w3.MustNewFunc("beforeDonate(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint256 amount0, uint256 amount1, bytes hookData)", "bytes4"), {0xb6, 0xf9, 0xde, 0x95}: w3.MustNewFunc("swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] path, address to, uint256 deadline)", ""), {0xb8, 0x8d, 0x4f, 0xde}: w3.MustNewFunc("safeTransferFrom(address from, address to, uint256 tokenId, bytes data)", ""), + {0xba, 0x08, 0x76, 0x52}: w3.MustNewFunc("redeem(uint256 shares, address receiver, address owner)", "uint256 assets"), {0xba, 0x9a, 0x7a, 0x56}: w3.MustNewFunc("MINIMUM_LIQUIDITY()", "uint256"), {0xba, 0xa2, 0xab, 0xde}: w3.MustNewFunc("removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline)", "uint256 amountA, uint256 amountB"), + {0xba, 0xba, 0x58, 0x55}: w3.MustNewFunc("fillOrderRFQTo((uint256 info, address makerAsset, address takerAsset, address maker, address allowedSender, uint256 makingAmount, uint256 takingAmount) order, bytes signature, uint256 makingAmount, uint256 takingAmount, address target)", ""), {0xba, 0xd1, 0xdc, 0x26}: w3.MustNewFunc("geometric_mean(uint256[3] x)", "uint256"), {0xbc, 0x25, 0xcf, 0x77}: w3.MustNewFunc("skim(address to)", ""), + {0xbd, 0x60, 0x15, 0xb4}: w3.MustNewFunc("sellBase(address to)", "uint256 receiveQuoteAmount"), {0xbe, 0x00, 0xbb, 0xd8}: w3.MustNewFunc("getApp(bytes32 namespace, bytes32 appId)", "address"), + {0xc0, 0x4b, 0x8d, 0x59}: w3.MustNewFunc("exactInput((bytes path, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum) params)", "uint256 amountOut"), {0xc3, 0x1b, 0x8d, 0x7a}: w3.MustNewFunc("swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96)", "int256 amount0, int256 amount1"), + {0xc3, 0x8a, 0x44, 0x74}: w3.MustNewFunc("swapSingleFromContract((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature)", ""), {0xc4, 0x5a, 0x01, 0x55}: w3.MustNewFunc("factory()", "address"), {0xc4, 0xbd, 0x89, 0xa9}: w3.MustNewFunc("UnsafeCast()", ""), + {0xc6, 0x3d, 0x75, 0xb6}: w3.MustNewFunc("maxMint(address receiver)", "uint256 maxShares"), {0xc6, 0x61, 0x06, 0x57}: w3.MustNewFunc("coins(uint256 i)", "address"), + {0xc6, 0xe6, 0xf5, 0x92}: w3.MustNewFunc("convertToShares(uint256 assets)", "uint256 shares"), {0xc8, 0x7b, 0x56, 0xdd}: w3.MustNewFunc("tokenURI(uint256 tokenId)", "string"), {0xc9, 0xc6, 0x53, 0x96}: w3.MustNewFunc("createPair(address tokenA, address tokenB)", "address pair"), {0xca, 0x15, 0xc8, 0x73}: w3.MustNewFunc("getRoleMemberCount(bytes32 role)", "uint256"), {0xca, 0xb4, 0x6b, 0xc6}: w3.MustNewFunc("setSwapFreeze(bool enable)", ""), + {0xcb, 0xf0, 0xbf, 0xac}: w3.MustNewFunc("rush()", "uint256 wad"), {0xcc, 0x94, 0xa6, 0x3a}: w3.MustNewFunc("NoSlice()", ""), {0xce, 0x7d, 0x65, 0x03}: w3.MustNewFunc("exchange(uint256 i, uint256 j, uint256 dx, uint256 min_dy, bool use_eth, address receiver)", "uint256"), + {0xce, 0x96, 0xcb, 0x77}: w3.MustNewFunc("maxWithdraw(address owner)", "uint256 maxAssets"), {0xce, 0xa9, 0xd2, 0x6f}: w3.MustNewFunc("rescueTokens(address token, address to, uint256 amount)", ""), {0xd0, 0x6c, 0xa6, 0x1f}: w3.MustNewFunc("getAmountsOut(uint256 amountIn, address[] path)", "uint256[] amounts"), + {0xd0, 0xa3, 0xb6, 0x65}: w3.MustNewFunc("fillOrderRFQ((uint256 info, address makerAsset, address takerAsset, address maker, address allowedSender, uint256 makingAmount, uint256 takingAmount) order, bytes signature, uint256 makingAmount, uint256 takingAmount)", ""), {0xd0, 0xc9, 0x3a, 0x7c}: w3.MustNewFunc("tickSpacing()", "int24"), {0xd0, 0xe3, 0x0d, 0xb0}: w3.MustNewFunc("deposit()", ""), {0xd2, 0x12, 0x20, 0xa7}: w3.MustNewFunc("token1()", "address"), + {0xd4, 0xb9, 0x70, 0x46}: w3.MustNewFunc("_QUOTE_TOKEN_()", "address"), {0xd4, 0xe0, 0x24, 0x8e}: w3.MustNewFunc("V3InvalidAmountOut()", ""), {0xd5, 0x05, 0xac, 0xcf}: w3.MustNewFunc("permit(address owner, address spender, uint256 amount, uint256 deadline, uint8 v, bytes32 r, bytes32 s)", ""), {0xd5, 0x47, 0x74, 0x1f}: w3.MustNewFunc("revokeRole(bytes32 role, address account)", ""), {0xd7, 0x6a, 0x1e, 0x9e}: w3.MustNewFunc("InvalidCommandType(uint256 commandType)", ""), + {0xd9, 0x05, 0x77, 0x7e}: w3.MustNewFunc("maxRedeem(address owner)", "uint256 maxShares"), {0xd9, 0x09, 0x6a, 0x3e}: w3.MustNewFunc("ToUint24OutOfBounds()", ""), + {0xd9, 0xc5, 0x5c, 0xe1}: w3.MustNewFunc("fill()", "uint256 wad"), + {0xdb, 0x3e, 0x21, 0x98}: w3.MustNewFunc("exactOutputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountOut, uint256 amountInMaximum, uint160 sqrtPriceLimitX96) params)", "uint256 amountIn"), + {0xdb, 0xd0, 0x35, 0xff}: w3.MustNewFunc("extsload(bytes32[] slots)", "bytes32[] values"), + {0xdc, 0x98, 0x35, 0x4e}: w3.MustNewFunc("beforeInitialize(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint160 sqrtPriceX96)", "bytes4"), {0xdd, 0x62, 0xed, 0x3e}: w3.MustNewFunc("allowance(address owner, address spender)", "uint256"), + {0xdd, 0x93, 0xf5, 0x9a}: w3.MustNewFunc("sellQuote(address to)", "uint256 receiveBaseAmount"), + {0xdd, 0x96, 0x99, 0x4f}: w3.MustNewFunc("exchange_extended(uint256 sellIndex, uint256 buyIndex, uint256 sellAmount, uint256 minBuyAmount, bool useEth, address payer, address receiver, bytes32 callbackSelector)", "uint256 buyAmount"), {0xdd, 0xc1, 0xf5, 0x9d}: w3.MustNewFunc("exchange(int128 i, int128 j, uint256 dx, uint256 min_dy, address receiver)", ""), {0xdd, 0xca, 0x3f, 0x43}: w3.MustNewFunc("fee()", "uint24"), {0xde, 0x28, 0x73, 0x59}: w3.MustNewFunc("acl()", "address"), {0xde, 0xaa, 0x01, 0xe6}: w3.MustNewFunc("InvalidBips()", ""), {0xde, 0xd9, 0x38, 0x2a}: w3.MustNewFunc("removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s)", "uint256 amountToken, uint256 amountETH"), + {0xe1, 0xb4, 0xaf, 0x69}: w3.MustNewFunc("afterDonate(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint256 amount0, uint256 amount1, bytes hookData)", "bytes4"), {0xe4, 0x49, 0x02, 0x2e}: w3.MustNewFunc("uniswapV3Swap(uint256 amount, uint256 minReturn, uint256[] pools)", "uint256 returnAmount"), {0xe4, 0x50, 0xd3, 0x8c}: w3.MustNewFunc("ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed)", ""), {0xe6, 0x02, 0xdf, 0x05}: w3.MustNewFunc("ERC20InvalidApprover(address approver)", ""), {0xe6, 0xa4, 0x39, 0x05}: w3.MustNewFunc("getPair(address tokenA, address tokenB)", "address pair"), + {0xe6, 0xfd, 0x60, 0x4c}: w3.MustNewFunc("cut()", "uint256 wad"), {0xe7, 0x00, 0x28, 0x77}: w3.MustNewFunc("FromAddressIsNotOwner()", ""), {0xe8, 0xe3, 0x37, 0x00}: w3.MustNewFunc("addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline)", "uint256 amountA, uint256 amountB, uint256 liquidity"), {0xe9, 0x85, 0xe9, 0xc5}: w3.MustNewFunc("isApprovedForAll(address owner, address operator)", "bool"), {0xeb, 0x8d, 0x21, 0x16}: w3.MustNewFunc("transferTokens((address from, address receiver, address[] tokens, uint256[] amounts, uint256[] nftIds, bytes tokenTransferTypes, uint16 fillPercent) transferData)", ""), {0xec, 0x44, 0x2f, 0x05}: w3.MustNewFunc("ERC20InvalidReceiver(address receiver)", ""), {0xec, 0x98, 0x37, 0x76}: w3.MustNewFunc("settleWithPermitsSignatures((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, (bytes[] permitSignatures, bytes signatureBytesPermit2, uint48[] noncesPermit2, uint48 deadline) takerPermitsInfo, (bool result, address to, uint256 value, bytes data)[] interactions, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (address balanceRecipient, uint16 curFillPercent) solverData)", ""), + {0xef, 0x7d, 0x27, 0xad}: w3.MustNewFunc("settleSingleAndSignPermit((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256 makerAmount, uint256 makerNonce) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint256 deadline) takerPermitSignature)", ""), + {0xef, 0x8b, 0x30, 0xf7}: w3.MustNewFunc("previewDeposit(uint256 assets)", "uint256 shares"), + {0xef, 0xe3, 0x4f, 0xe6}: w3.MustNewFunc("settleMulti((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address[] takerTokens, address[] makerTokens, uint256[] takerAmounts, uint256[] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256[] makerAmounts, uint256 makerNonce) takerQuoteInfo, bytes takerSignature)", ""), + {0xf0, 0x2d, 0xe3, 0xb2}: w3.MustNewFunc("protocolFeeController()", "address"), + {0xf1, 0x35, 0xba, 0xaa}: w3.MustNewFunc("exttload(bytes32 slot)", "bytes32 value"), + {0xf2, 0x8c, 0x04, 0x98}: w3.MustNewFunc("exactOutput((bytes path, address recipient, uint256 deadline, uint256 amountOut, uint256 amountInMaximum) params)", "uint256 amountIn"), {0xf2, 0xfd, 0xe3, 0x8b}: w3.MustNewFunc("transferOwnership(address newOwner)", ""), {0xf3, 0x05, 0x83, 0x99}: w3.MustNewFunc("feeGrowthGlobal0X128()", "uint256"), {0xf3, 0x05, 0xd7, 0x19}: w3.MustNewFunc("addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline)", "uint256 amountToken, uint256 amountETH, uint256 liquidity"), {0xf4, 0x2c, 0x56, 0xc2}: w3.MustNewFunc("cbrt(uint256 x)", "uint256"), {0xf4, 0x93, 0xca, 0x70}: w3.MustNewFunc("sellAssetWithSig(address originator, uint256 maxAmount, address receiver, uint256 deadline, bytes signature)", "uint256, uint256"), + {0xf5, 0x29, 0x8a, 0xca}: w3.MustNewFunc("burn(address from, uint256 id, uint256 amount)", ""), {0xf8, 0x51, 0xa4, 0x40}: w3.MustNewFunc("admin()", "address"), {0xfa, 0x18, 0x04, 0x2d}: w3.MustNewFunc("reduction_coefficient(uint256[3] x, uint256 fee_gamma)", "uint256"), {0xfa, 0x46, 0x1e, 0x33}: w3.MustNewFunc("uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes data)", ""), {0xfa, 0x6e, 0x67, 0x1d}: w3.MustNewFunc("setRelayerApproval(address sender, address relayer, bool approved)", ""), + {0xfa, 0xe0, 0x36, 0xd5}: w3.MustNewFunc("tout()", "uint256"), {0xfb, 0x3b, 0xdb, 0x41}: w3.MustNewFunc("swapETHForExactTokens(uint256 amountOut, address[] path, address to, uint256 deadline)", "uint256[] amounts"), {0xfb, 0x8f, 0x41, 0xb2}: w3.MustNewFunc("ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed)", ""), {0xfc, 0x0c, 0x54, 0x6a}: w3.MustNewFunc("token()", "address"), diff --git a/internal/fourbyte/funcs.txt b/internal/fourbyte/funcs.txt index b219e224..8d429483 100644 --- a/internal/fourbyte/funcs.txt +++ b/internal/fourbyte/funcs.txt @@ -1,35 +1,62 @@ +_BASE_TOKEN_() address +_QUOTE_TOKEN_() address accumulateReward(uint32 currTimestamp) acl() address addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) uint256 amountA, uint256 amountB, uint256 liquidity addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) uint256 amountToken, uint256 amountETH, uint256 liquidity admin() address +afterAddLiquidity(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, int256 delta, int256 feesAccrued, bytes hookData) bytes4, int256 +afterDonate(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint256 amount0, uint256 amount1, bytes hookData) bytes4 +afterInitialize(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint160 sqrtPriceX96, int24 tick) bytes4 +afterRemoveLiquidity(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, int256 delta, int256 feesAccrued, bytes hookData) bytes4, int256 +afterSwap(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96) params, int256 delta, bytes hookData) bytes4, int128 allowance(address owner, address spender) uint256 allowance(address user, address token, address spender) uint160 amount, uint48 expiration, uint48 nonce allPairsLength() uint256 approve(address spender, uint256 amount) bool success +asset() address assetTokenAddress balanceOf(address) uint256 batchSwap(uint8 swapKind, (bytes32 poolId, uint256 assetInIndex, uint256 assetOutIndex, uint256 amount, bytes data)[] swaps, address[] assets, (address sender, bool fromInternalBalance, address recipient, bool toInternalBalance) funds, int256[] limits, uint256 deadline) int256[] +beforeAddLiquidity(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, bytes hookData) bytes4 +beforeDonate(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint256 amount0, uint256 amount1, bytes hookData) bytes4 +beforeInitialize(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint160 sqrtPriceX96) bytes4 +beforeRemoveLiquidity(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, bytes hookData) bytes4 +beforeSwap(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96) params, bytes hookData) bytes4, int256, uint24 +burn(address from, uint256 id, uint256 amount) burn(address user, uint256 amount) burn(uint256) burnAfterSeize(uint256 amount) uint256 burnFrom(address to, uint256 value) bool buyAsset(uint256 minAmount, address receiver) uint256, uint256 buyAssetWithSig(address originator, uint256 minAmount, address receiver, uint256 deadline, bytes signature) uint256, uint256 +buyGem(address usr, uint256 gemAmt) uint256 daiInWad +buyGemNoFee(address usr, uint256 gemAmt) uint256 daiInWad +cancelOrderRFQ(uint256 orderInfo) canPerform(bytes32 actionId, address account, address where) bool cbrt(uint256 x) uint256 +chug() uint256 wad claimMintReward() claimMintRewardAndShare(address other, uint256 pct) claimMintRewardAndStake(uint256 pct, uint256 term) +clear(address currency, uint256 amount) coins(uint256 i) address +collectProtocolFees(address recipient, address currency, uint256 amount) uint256 amountCollected ContractLocked() +convertToAssets(uint256 shares) uint256 assets +convertToShares(uint256 assets) uint256 shares createPair(address tokenA, address tokenB) address pair crossLmTick(int24 tick, bool zeroForOne) cumulativeSum() uint256 +curveTricryptoSwapCallback(address payer, address receiver, address sellToken, uint256 sellAmount, uint256 buyAmount) +cut() uint256 wad +dec() uint256 decimals() uint8 decreaseAllowance(address spender, uint256 subtractedValue) bool success deposit() +deposit(uint256 assets, address receiver) uint256 shares description() string DOMAIN_SEPARATOR() bytes32 +donate((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint256 amount0, uint256 amount1, bytes hookData) int256 delta ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed) ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed) ERC20InvalidApprover(address approver) @@ -46,26 +73,43 @@ ERC721InvalidSender(address sender) ERC721NonexistentToken(uint256 tokenId) Error(string) ETHNotAccepted() +exactInput((bytes path, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum) params) uint256 amountOut +exactInputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96) params) uint256 amountOut +exactOutput((bytes path, address recipient, uint256 deadline, uint256 amountOut, uint256 amountInMaximum) params) uint256 amountIn +exactOutputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountOut, uint256 amountInMaximum, uint160 sqrtPriceLimitX96) params) uint256 amountIn exchange(int128 i, int128 j, uint256 dx, uint256 min_dy) exchange(int128 i, int128 j, uint256 dx, uint256 min_dy, address receiver) exchange(uint256 i, uint256 j, uint256 dx, uint256 min_dy) exchange(uint256 i, uint256 j, uint256 dx, uint256 min_dy, bool use_eth) exchange(uint256 i, uint256 j, uint256 dx, uint256 min_dy, bool use_eth, address receiver) uint256 +exchange_extended(uint256 sellIndex, uint256 buyIndex, uint256 sellAmount, uint256 minBuyAmount, bool useEth, address payer, address receiver, bytes32 callbackSelector) uint256 buyAmount exchange_underlying(int128 i, int128 j, uint256 dx, uint256 min_dy) +exec(address operator, address token, uint256 amount, address target, bytes data) bytes result execute(bytes commands, bytes[] inputs) execute(bytes commands, bytes[] inputs, uint256 deadline) ExecutionFailed(uint256 commandIndex, bytes message) +extsload(bytes32 slot) bytes32 value +extsload(bytes32 startSlot, uint256 nSlots) bytes32[] values +extsload(bytes32[] slots) bytes32[] values +exttload(bytes32 slot) bytes32 value +exttload(bytes32[] slots) bytes32[] values factory() address fee() uint24 feeGrowthGlobal0X128() uint256 feeGrowthGlobal1X128() uint256 +fill() uint256 wad +fillOrderRFQ((uint256 info, address makerAsset, address takerAsset, address maker, address allowedSender, uint256 makingAmount, uint256 takingAmount) order, bytes signature, uint256 makingAmount, uint256 takingAmount) +fillOrderRFQTo((uint256 info, address makerAsset, address takerAsset, address maker, address allowedSender, uint256 makingAmount, uint256 takingAmount) order, bytes signature, uint256 makingAmount, uint256 takingAmount, address target) fillQuoteEthToToken(address buyTokenAddress, address target, bytes swapCallData, uint256 feeAmount) fillQuoteTokenToEth(address sellTokenAddress, address target, bytes swapCallData, uint256 sellAmount, uint256 feePercentageBasisPoints) fillQuoteTokenToEthWithPermit(address sellTokenAddress, address target, bytes swapCallData, uint256 sellAmount, uint256 feePercentageBasisPoints, (uint256 value, uint256 nonce, uint256 deadline, bool isDaiStylePermit, uint8 v, bytes32 r, bytes32 s) permitData) fillQuoteTokenToToken(address sellTokenAddress, address buyTokenAddress, address target, bytes swapCallData, uint256 sellAmount, uint256 feeAmount) fillQuoteTokenToTokenWithPermit(address sellTokenAddress, address buyTokenAddress, address target, bytes swapCallData, uint256 sellAmount, uint256 feeAmount, (uint256 value, uint256 nonce, uint256 deadline, bool isDaiStylePermit, uint8 v, bytes32 r, bytes32 s) permitData) +fillRfqOrderSelfFunded(address recipient, (address token, uint256 amount, uint256 nonce, uint256 deadline) permitted, address maker, bytes makerSig, address takerToken, uint256 maxTakerAmount) +fillRfqOrderVIP(address recipient, (address token, uint256 amount, uint256 nonce, uint256 deadline) makerPermit, address maker, bytes makerSig, (address token, uint256 amount, uint256 nonce, uint256 deadline) takerPermit, bytes takerSig) flash(address recipient, uint256 amount0, uint256 amount1, bytes data) FromAddressIsNotOwner() +gemJoin() address geometric_mean(uint256[3] x) uint256 get_address(uint256 idx) address get_dy(int128 i, int128 j, uint256 amount) uint256 @@ -94,11 +138,13 @@ getRoleMemberCount(bytes32 role) uint256 getRoundData(uint80 roundId) uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound getSellFee(uint256 grossAmount) uint256 grantRole(bytes32 role, address account) +gush() uint256 wad hasApprovedRelayer(address user, address relayer) bool hasPermission(address who, address where, bytes32 what, bytes how) bool hasRole(bytes32 role, address account) bool implementation() address increaseAllowance(address spender, uint256 addedValue) bool success +initialize((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint160 sqrtPriceX96) int24 tick initialize(address token0, address token1) InsufficientETH() InsufficientToken() @@ -114,18 +160,28 @@ isValidSignature(bytes32 hash, bytes data) bytes4 magic kLast() uint256 latestRoundData() uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound liquidity() uint128 +live() uint256 lmPool() address +maverickV2SwapCallback(address tokenIn, uint256 amountIn, uint256 amountOut, bytes data) max(uint256, uint256) uint256 +maxDeposit(address receiver) uint256 maxAssets +maxMint(address receiver) uint256 maxShares +maxRedeem(address owner) uint256 maxShares +maxWithdraw(address owner) uint256 maxAssets min(uint256, uint256) uint256 MINIMUM_LIQUIDITY() uint256 mint() mint(address to, uint256 amount) +mint(address to, uint256 id, uint256 amount) +mint(uint256 shares, address receiver) uint256 assets mint(uint256) mint_relative(address to, uint256 frac) uint256 +modifyLiquidity((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, bytes hookData) int256 callerDelta, int256 feesAccrued name() string newton_D(uint256 ANN, uint256 gamma, uint256[3] x_unsorted, uint256 K0_prev) uint256 NoSlice() onERC721Received(address operator, address from, uint256 tokenId, bytes data) bytes4 +onSwap((uint8 kind, address tokenIn, address tokenOut, uint256 amount, bytes32 poolId, uint256 lastChangeBlock, address from, address to, bytes userData) swapRequest, uint256[] balances, uint256 indexIn, uint256 indexOut) uint256 amount owner() address ownerOf(uint256 tokenId) address pancakeV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes data) @@ -133,9 +189,16 @@ Panic(uint256) paused() bool permit(address owner, ((address token, uint160 amount, uint48 expiration, uint48 nonce)[] details, address spender, uint256 sigDeadline) permitBatch, bytes signature) permit(address owner, address spender, uint256 amount, uint256 deadline, uint8 v, bytes32 r, bytes32 s) +previewDeposit(uint256 assets) uint256 shares +previewMint(uint256 shares) uint256 assets +previewRedeem(uint256 shares) uint256 assets +previewWithdraw(uint256 assets) uint256 shares price0CumulativeLast() uint256 price1CumulativeLast() uint256 +protocolFeeController() address +protocolFeesAccrued(address currency) uint256 amount quote(uint256 amountA, uint256 reserveA, uint256 reserveB) uint256 amountB +redeem(uint256 shares, address receiver, address owner) uint256 assets reduction_coefficient(uint256[3] x, uint256 fee_gamma) uint256 removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) uint256 amountA, uint256 amountB removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) uint256 amountToken, uint256 amountETH @@ -147,22 +210,39 @@ renounceOwnership() renounceRole(bytes32 role, address account) rescueTokens(address token, address to, uint256 amount) revokeRole(bytes32 role, address account) +rush() uint256 wad safeTransferFrom(address from, address to, uint256 tokenId) safeTransferFrom(address from, address to, uint256 tokenId, bytes data) seize() uint256 sellAsset(uint256 maxAmount, address receiver) uint256, uint256 sellAssetWithSig(address originator, uint256 maxAmount, address receiver, uint256 deadline, bytes signature) uint256, uint256 +sellBase(address to) uint256 receiveQuoteAmount +sellGem(address usr, uint256 gemAmt) uint256 daiOutWad +sellQuote(address to) uint256 receiveBaseAmount setApp(bytes32 namespace, bytes32 appId, address app) setApprovalForAll(address operator, bool approved) setAuthorizer(address newAuthorizer) +setProtocolFee((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint24 newProtocolFee) +setProtocolFeeController(address controller) setRelayerApproval(address sender, address relayer, bool approved) setSwapFeePercentage(uint256) setSwapFreeze(bool enable) settle((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, (bool result, address to, uint256 value, bytes data)[] interactions, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (address balanceRecipient, uint16 curFillPercent) solverData) +settle() uint256 paid settle(address[] tokens, uint256[] clearingPrices, (uint256 sellTokenIndex, uint256 buyTokenIndex, address receiver, uint256 sellAmount, uint256 buyAmount, uint32 validTo, bytes32 appData, uint256 feeAmount, uint256 flags, uint256 executedAmount, bytes signature)[] trades, (address target, uint256 value, bytes callData)[][3] interactions) +settleAggregate((uint256 expiry, address takerAddress, address[] makerAddresses, uint256[] makerNonces, address[][] takerTokens, address[][] makerTokens, uint256[][] takerAmounts, uint256[][] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags)[] makersSignatures, uint256 filledTakerAmount, (bool useOldAmount, uint256[][] makerAmounts, uint256[] makerNonces) takerQuoteInfo, bytes takerSignature) +settleAggregateAndSignPermit((uint256 expiry, address takerAddress, address[] makerAddresses, uint256[] makerNonces, address[][] takerTokens, address[][] makerTokens, uint256[][] takerAmounts, uint256[][] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags)[] makersSignatures, uint256 filledTakerAmount, (bool useOldAmount, uint256[][] makerAmounts, uint256[] makerNonces) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint256 deadline) takerPermitSignature) +settleAggregateAndSignPermit2((uint256 expiry, address takerAddress, address[] makerAddresses, uint256[] makerNonces, address[][] takerTokens, address[][] makerTokens, uint256[][] takerAmounts, uint256[][] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags)[] makersSignatures, uint256 filledTakerAmount, (bool useOldAmount, uint256[][] makerAmounts, uint256[] makerNonces) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint48 deadline, uint48[] nonces) infoPermit2) settleBatch((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers)[] orders, (uint8 type, bytes signatureBytes)[] signatures, (bytes[] permitSignatures, bytes signatureBytesPermit2, uint48[] noncesPermit2, uint48 deadline)[] takersPermitsInfo, (bool result, address to, uint256 value, bytes data)[] interactions, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle)[] hooks, (address balanceRecipient, uint16[] curFillPercents, bool[] takersPermitsUsage, bool transferExactAmounts) solverData) +settleFor(address recipient) uint256 paid settleInternal((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (uint256[] increasedBuyAmounts, uint16 curFillPercent) makerData) settleInternalWithPermitsSignatures((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, (bytes[] permitSignatures, bytes signatureBytesPermit2, uint48[] noncesPermit2, uint48 deadline) takerPermitsInfo, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (uint256[] increasedBuyAmounts, uint16 curFillPercent) makerData) +settleMulti((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address[] takerTokens, address[] makerTokens, uint256[] takerAmounts, uint256[] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256[] makerAmounts, uint256 makerNonce) takerQuoteInfo, bytes takerSignature) +settleMultiAndSignPermit((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address[] takerTokens, address[] makerTokens, uint256[] takerAmounts, uint256[] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256[] makerAmounts, uint256 makerNonce) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint256 deadline) takerPermitSignature) +settleMultiAndSignPermit2((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address[] takerTokens, address[] makerTokens, uint256[] takerAmounts, uint256[] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256[] makerAmounts, uint256 makerNonce) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint48 deadline, uint48[] nonces) infoPermit2) +settleSingle((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256 makerAmount, uint256 makerNonce) takerQuoteInfo, bytes takerSignature) +settleSingleAndSignPermit((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256 makerAmount, uint256 makerNonce) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint256 deadline) takerPermitSignature) +settleSingleAndSignPermit2((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256 makerAmount, uint256 makerNonce) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint48 deadline, uint48 nonce) takerPermit2Signature) settleWithPermitsSignatures((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, (bytes[] permitSignatures, bytes signatureBytesPermit2, uint48[] noncesPermit2, uint48 deadline) takerPermitsInfo, (bool result, address to, uint256 value, bytes data)[] interactions, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (address balanceRecipient, uint16 curFillPercent) solverData) skim(address to) SliceOutOfBounds() @@ -180,6 +260,7 @@ swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPri swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, uint256 amountLimit, uint256 deadline, uint256 trackingCode) int256 amount0, int256 amount1 swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, uint256 trackingCode) int256 amount0, int256 amount1 swap(uint256 amount0Out, uint256 amount1Out, address to, bytes data) +swapAggregate((uint256 expiry, address takerAddress, address[] makerAddresses, uint256[] makerNonces, address[][] takerTokens, address[][] makerTokens, uint256[][] takerAmounts, uint256[][] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags)[] makersSignatures, uint256 filledTakerAmount) swapETHForExactTokens(uint256 amountOut, address[] path, address to, uint256 deadline) uint256[] amounts swapExactETHForTokens(uint256 amountOutMin, address[] path, address to, uint256 deadline) uint256[] amounts swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] path, address to, uint256 deadline) @@ -187,35 +268,48 @@ swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] path, ad swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline) swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline) uint256[] amounts swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline) +swapMulti((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address[] takerTokens, address[] makerTokens, uint256[] takerAmounts, uint256[] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount) +swapSingle((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount) +swapSingleFromContract((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature) swapTargets(address) bool swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] path, address to, uint256 deadline) uint256[] amounts swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] path, address to, uint256 deadline) uint256[] amounts symbol() string sync() +sync(address currency) +take(address currency, address to, uint256 amount) tickSpacing() int24 ToAddressOutOfBounds() ToAddressOverflow() token() address token0() address token1() address +tokenA() address +tokenB() address tokenURI(uint256 tokenId) string +totalAssets() uint256 totalManagedAssets totalShares() uint256 totalSupply() uint256 ToUint24OutOfBounds() ToUint24Overflow() +tout() uint256 TransactionDeadlinePassed() transfer(address to, uint256 amount) bool success transferFrom((address from, address to, uint160 amount, address token)[] transferDetails) transferFrom(address from, address to, uint160 amount, address token) transferFrom(address from, address to, uint256 amount) bool success +transferFrom(address token, address owner, address recipient, uint256 amount) bool transferFromAccounts((address account, address token, uint256 amount, bytes32 balance)[]) transferOwnership(address newOwner) transferTokens((address from, address receiver, address[] tokens, uint256[] amounts, uint256[] nftIds, bytes tokenTransferTypes, uint16 fillPercent) transferData) +trim() uint256 wad UnableToClaim() uniswapV3Swap(uint256 amount, uint256 minReturn, uint256[] pools) uint256 returnAmount uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes data) +unlock(bytes data) bytes UnsafeCast() updatedAt() uint256 +updateDynamicLPFee((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint24 newDynamicLPFee) updateSwapTargets(address target, bool add) V2InvalidPath() V2TooLittleReceived() @@ -228,6 +322,7 @@ V3TooMuchRequested() version() uint256 wad_exp(int256 power) uint256 WETH() address +withdraw(uint256 assets, address receiver, address owner) uint256 shares withdraw(uint256) withdrawEth(address to, uint256 amount) withdrawToken(address token, address to, uint256 amount) From 5b84a38c2c031f4e25951616be8cbb2575895502 Mon Sep 17 00:00:00 2001 From: lmittmann Date: Wed, 2 Apr 2025 09:08:58 +0200 Subject: [PATCH 08/11] added more funcs --- internal/fourbyte/funcs.go | 118 ++++++++++++++++++++++++++++++++++++ internal/fourbyte/funcs.txt | 118 ++++++++++++++++++++++++++++++++++++ 2 files changed, 236 insertions(+) diff --git a/internal/fourbyte/funcs.go b/internal/fourbyte/funcs.go index 4eaa1d0b..c80f64ea 100644 --- a/internal/fourbyte/funcs.go +++ b/internal/fourbyte/funcs.go @@ -4,7 +4,9 @@ package fourbyte import "github.com/lmittmann/w3" var functions = map[[4]byte]*w3.Func{ + {0x01, 0x57, 0xaa, 0x77}: w3.MustNewFunc("updateProtocolLendingFeeRateForPool(address pool)", ""), {0x01, 0x66, 0x4f, 0x66}: w3.MustNewFunc("gemJoin()", "address"), + {0x01, 0xda, 0x15, 0x72}: w3.MustNewFunc("InvalidOffset()", ""), {0x01, 0xe1, 0xd1, 0x14}: w3.MustNewFunc("totalAssets()", "uint256 totalManagedAssets"), {0x01, 0xe3, 0x36, 0x67}: w3.MustNewFunc("withdrawToken(address token, address to, uint256 amount)", ""), {0x01, 0xec, 0x95, 0x4a}: w3.MustNewFunc("onSwap((uint8 kind, address tokenIn, address tokenOut, uint256 amount, bytes32 poolId, uint256 lastChangeBlock, address from, address to, bytes userData) swapRequest, uint256[] balances, uint256 indexIn, uint256 indexOut)", "uint256 amount"), @@ -12,6 +14,7 @@ var functions = map[[4]byte]*w3.Func{ {0x02, 0x2c, 0x0d, 0x9f}: w3.MustNewFunc("swap(uint256 amount0Out, uint256 amount1Out, address to, bytes data)", ""), {0x02, 0x75, 0x1c, 0xec}: w3.MustNewFunc("removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline)", "uint256 amountToken, uint256 amountETH"), {0x02, 0xcc, 0x25, 0x0d}: w3.MustNewFunc("isSolver(address)", "bool"), + {0x03, 0xa1, 0xc0, 0xbb}: w3.MustNewFunc("PoolFunctionNotImplemented()", ""), {0x05, 0x4d, 0x50, 0xd4}: w3.MustNewFunc("getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut)", "uint256 amountOut"), {0x05, 0x8a, 0x62, 0x8f}: w3.MustNewFunc("setAuthorizer(address newAuthorizer)", ""), {0x06, 0x7d, 0x92, 0x74}: w3.MustNewFunc("buyGemNoFee(address usr, uint256 gemAmt)", "uint256 daiInWad"), @@ -22,7 +25,9 @@ var functions = map[[4]byte]*w3.Func{ {0x08, 0xc3, 0x79, 0xa0}: w3.MustNewFunc("Error(string)", ""), {0x09, 0x02, 0xf1, 0xac}: w3.MustNewFunc("getReserves()", "uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast"), {0x09, 0x5e, 0xa7, 0xb3}: w3.MustNewFunc("approve(address spender, uint256 amount)", "bool success"), + {0x09, 0x78, 0x52, 0x5c}: w3.MustNewFunc("createPermissioned(uint64 feeAIn, uint64 feeBIn, uint16 tickSpacing, uint32 lookback, address tokenA, address tokenB, int32 activeTick, uint8 kinds, address accessor, bool permissionedLiquidity, bool permissionedSwap)", "address pool"), {0x0a, 0x28, 0xa4, 0x77}: w3.MustNewFunc("previewWithdraw(uint256 assets)", "uint256 shares"), + {0x0a, 0x5f, 0x0b, 0x03}: w3.MustNewFunc("createPermissioned(uint64 feeAIn, uint64 feeBIn, uint16 tickSpacing, uint32 lookback, address tokenA, address tokenB, int32 activeTick, uint8 kinds, address accessor)", "address"), {0x0b, 0x0d, 0x9c, 0x09}: w3.MustNewFunc("take(address currency, address to, uint256 amount)", ""), {0x0c, 0x03, 0x3b, 0x9b}: w3.MustNewFunc("swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, uint256 amountLimit, uint256 deadline, bytes data)", "int256 amount0, int256 amount1"), {0x0d, 0x58, 0xb1, 0xdb}: w3.MustNewFunc("transferFrom((address from, address to, uint160 amount, address token)[] transferDetails)", ""), @@ -30,6 +35,8 @@ var functions = map[[4]byte]*w3.Func{ {0x0f, 0x5a, 0x6e, 0xfa}: w3.MustNewFunc("getInternalBalance(address user, address[] tokens)", "uint256[]"), {0x0f, 0xc6, 0x3d, 0x10}: w3.MustNewFunc("tokenA()", "address"), {0x11, 0xda, 0x60, 0xb4}: w3.MustNewFunc("settle()", "uint256 paid"), + {0x12, 0x0d, 0xe7, 0x79}: w3.MustNewFunc("permissionedPool()", "bool permissionedPool"), + {0x12, 0x21, 0x0e, 0x8a}: w3.MustNewFunc("refundETH()", ""), {0x12, 0x31, 0xae, 0x40}: w3.MustNewFunc("ETHNotAccepted()", ""), {0x12, 0x49, 0xc5, 0x8b}: w3.MustNewFunc("mint()", ""), {0x12, 0x8a, 0xcb, 0x08}: w3.MustNewFunc("swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, bytes data)", "int256 amount0, int256 amount1"), @@ -42,19 +49,26 @@ var functions = map[[4]byte]*w3.Func{ {0x17, 0x32, 0x60, 0xeb}: w3.MustNewFunc("settleInternal((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (uint256[] increasedBuyAmounts, uint16 curFillPercent) makerData)", ""), {0x17, 0x7e, 0x80, 0x2f}: w3.MustNewFunc("ERC721InsufficientApproval(address operator, uint256 tokenId)", ""), {0x18, 0x16, 0x0d, 0xdd}: w3.MustNewFunc("totalSupply()", "uint256"), + {0x18, 0x65, 0xc5, 0x7d}: w3.MustNewFunc("getState()", "(uint128 reserveA, uint128 reserveB, int64 lastTwaD8, int64 lastLogPriceD8, uint40 lastTimestamp, int32 activeTick, bool isLocked, uint32 binCounter, uint8 protocolFeeRatioD3)"), {0x18, 0xcb, 0xaf, 0xe5}: w3.MustNewFunc("swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline)", "uint256[] amounts"), {0x18, 0xfd, 0xd0, 0x6b}: w3.MustNewFunc("getGrossAmountFromTotalSold(uint256 totalAmount)", "uint256"), {0x1a, 0x49, 0x90, 0x26}: w3.MustNewFunc("settleSingle((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256 makerAmount, uint256 makerNonce) takerQuoteInfo, bytes takerSignature)", ""), {0x1a, 0x68, 0x65, 0x02}: w3.MustNewFunc("liquidity()", "uint128"), {0x1b, 0x9a, 0x91, 0xa4}: w3.MustNewFunc("withdrawEth(address to, uint256 amount)", ""), + {0x1c, 0x50, 0x0e, 0x5c}: w3.MustNewFunc("ForwarderNotAllowed()", ""), {0x1c, 0x56, 0x03, 0x05}: w3.MustNewFunc("claimMintRewardAndShare(address other, uint256 pct)", ""), + {0x1d, 0xe2, 0x83, 0xa6}: w3.MustNewFunc("protocolFeeRatioD3()", "uint8"), + {0x1e, 0x09, 0x21, 0x04}: w3.MustNewFunc("PermissionDenied()", ""), {0x1e, 0x2e, 0xae, 0xaf}: w3.MustNewFunc("extsload(bytes32 slot)", "bytes32 value"), {0x1f, 0x00, 0xca, 0x74}: w3.MustNewFunc("getAmountsIn(uint256 amountOut, address[] path)", "uint256[] amounts"), {0x20, 0xdb, 0x82, 0x67}: w3.MustNewFunc("InvalidPath()", ""), + {0x21, 0x27, 0x2d, 0x4c}: w3.MustNewFunc("tokenBScale()", "uint256"), {0x21, 0x4a, 0x6f, 0xe2}: w3.MustNewFunc("accumulateReward(uint32 currTimestamp)", ""), {0x21, 0x95, 0x99, 0x5c}: w3.MustNewFunc("removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s)", "uint256 amountA, uint256 amountB"), {0x21, 0xd0, 0xee, 0x70}: w3.MustNewFunc("beforeRemoveLiquidity(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, bytes hookData)", "bytes4"), {0x22, 0x13, 0xbc, 0x0b}: w3.MustNewFunc("exec(address operator, address token, uint256 amount, address target, bytes data)", "bytes result"), + {0x22, 0x17, 0x5a, 0x32}: w3.MustNewFunc("removeImplementation(address implementation)", ""), + {0x22, 0xcd, 0x85, 0xa8}: w3.MustNewFunc("getBin(uint32 binId)", "(uint128 mergeBinBalance, uint128 tickBalance, uint128 totalSupply, uint8 kind, int32 tick, uint32 mergeId) bin"), {0x23, 0x42, 0x66, 0xd7}: w3.MustNewFunc("donate((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint256 amount0, uint256 amount1, bytes hookData)", "int256 delta"), {0x23, 0xa6, 0x9e, 0x75}: w3.MustNewFunc("pancakeV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes data)", ""), {0x23, 0xb8, 0x72, 0xdd}: w3.MustNewFunc("transferFrom(address from, address to, uint256 amount)", "bool success"), @@ -64,32 +78,49 @@ var functions = map[[4]byte]*w3.Func{ {0x28, 0xb2, 0xa7, 0x96}: w3.MustNewFunc("settleInternalWithPermitsSignatures((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, (bytes[] permitSignatures, bytes signatureBytesPermit2, uint48[] noncesPermit2, uint48 deadline) takerPermitsInfo, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (uint256[] increasedBuyAmounts, uint16 curFillPercent) makerData)", ""), {0x2a, 0x2d, 0x80, 0xd1}: w3.MustNewFunc("permit(address owner, ((address token, uint160 amount, uint48 expiration, uint48 nonce)[] details, address spender, uint256 sigDeadline) permitBatch, bytes signature)", ""), {0x2c, 0x40, 0x29, 0xe9}: w3.MustNewFunc("ExecutionFailed(uint256 commandIndex, bytes message)", ""), + {0x2c, 0x50, 0xf4, 0xbe}: w3.MustNewFunc("PoolValueExceedsBits(uint256 amount, uint256 bits)", ""), {0x2d, 0x77, 0x13, 0x89}: w3.MustNewFunc("setProtocolFeeController(address controller)", ""), + {0x2d, 0x9d, 0x1c, 0xa6}: w3.MustNewFunc("fee(bool tokenAIn)", "uint256"), + {0x2e, 0x13, 0x67, 0x45}: w3.MustNewFunc("PoolLocked()", ""), {0x2e, 0x1a, 0x7d, 0x4d}: w3.MustNewFunc("withdraw(uint256)", ""), {0x2f, 0x2f, 0xf1, 0x5d}: w3.MustNewFunc("grantRole(bytes32 role, address account)", ""), {0x31, 0x3c, 0xe5, 0x67}: w3.MustNewFunc("decimals()", "uint8"), {0x31, 0x6c, 0xf0, 0xeb}: w3.MustNewFunc("V3InvalidSwap()", ""), + {0x31, 0xad, 0x53, 0xfa}: w3.MustNewFunc("protocolLendingFeeRateD18()", "uint256"), + {0x32, 0x56, 0xcf, 0xa9}: w3.MustNewFunc("getTick(int32 tick)", "(uint128 reserveA, uint128 reserveB, uint128 totalSupply, uint32[4] binIdsByTick) tickState"), + {0x32, 0x68, 0xf2, 0xb9}: w3.MustNewFunc("lookupPermissioned(address _tokenA, address _tokenB, address accessor, uint256 startIndex, uint256 endIndex)", "address[] pools"), {0x32, 0xb1, 0x3d, 0x91}: w3.MustNewFunc("V3InvalidCaller()", ""), + {0x33, 0x51, 0xb2, 0x60}: w3.MustNewFunc("DeltaNotNegative(address token)", ""), {0x35, 0x93, 0x56, 0x4c}: w3.MustNewFunc("execute(bytes commands, bytes[] inputs, uint256 deadline)", ""), {0x35, 0xfd, 0x63, 0x1a}: w3.MustNewFunc("extsload(bytes32 startSlot, uint256 nSlots)", "bytes32[] values"), + {0x36, 0x29, 0x4f, 0xf5}: w3.MustNewFunc("RouterNotFactoryPool()", ""), {0x36, 0x44, 0xe5, 0x15}: w3.MustNewFunc("DOMAIN_SEPARATOR()", "bytes32"), {0x36, 0x56, 0x8a, 0xbe}: w3.MustNewFunc("renounceRole(bytes32 role, address account)", ""), {0x36, 0xc7, 0x85, 0x16}: w3.MustNewFunc("transferFrom(address from, address to, uint160 amount, address token)", ""), + {0x37, 0x28, 0xb8, 0x3d}: w3.MustNewFunc("InvalidAmount(uint256 maxAmount)", ""), {0x38, 0x4e, 0xad, 0xa0}: w3.MustNewFunc("settleMultiAndSignPermit((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address[] takerTokens, address[] makerTokens, uint256[] takerAmounts, uint256[] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256[] makerAmounts, uint256 makerNonce) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint256 deadline) takerPermitSignature)", ""), {0x38, 0x50, 0xc7, 0xbd}: w3.MustNewFunc("slot0()", "(uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint8 feeProtocol, bool unlocked)"), {0x38, 0xd5, 0x2e, 0x0f}: w3.MustNewFunc("asset()", "address assetTokenAddress"), {0x38, 0xe9, 0x92, 0x2e}: w3.MustNewFunc("setSwapFeePercentage(uint256)", ""), {0x38, 0xec, 0x02, 0x11}: w3.MustNewFunc("settleSingleAndSignPermit2((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256 makerAmount, uint256 makerNonce) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint48 deadline, uint48 nonce) takerPermit2Signature)", ""), {0x38, 0xed, 0x17, 0x39}: w3.MustNewFunc("swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline)", "uint256[] amounts"), + {0x38, 0xef, 0x02, 0x53}: w3.MustNewFunc("permissionedSwap()", "bool permissionedSwap"), {0x39, 0x47, 0x47, 0xc5}: w3.MustNewFunc("exchange(uint256 i, uint256 j, uint256 dx, uint256 min_dy, bool use_eth)", ""), {0x39, 0x50, 0x93, 0x51}: w3.MustNewFunc("increaseAllowance(address spender, uint256 addedValue)", "bool success"), + {0x39, 0xa5, 0x1b, 0xe5}: w3.MustNewFunc("protocolFeeReceiver()", "address"), {0x39, 0xd3, 0x54, 0x96}: w3.MustNewFunc("V3TooLittleReceived()", ""), + {0x39, 0xde, 0x6d, 0xf5}: w3.MustNewFunc("PoolTokenNotSolvent(uint256 internalReserve, uint256 tokenBalance, address token)", ""), {0x3a, 0x98, 0xef, 0x39}: w3.MustNewFunc("totalShares()", "uint256"), + {0x3a, 0xb7, 0x2c, 0x10}: w3.MustNewFunc("tokenAScale()", "uint256"), {0x3b, 0x99, 0xb5, 0x3d}: w3.MustNewFunc("SliceOutOfBounds()", ""), {0x3c, 0x2b, 0x9a, 0x7d}: w3.MustNewFunc("fillQuoteEthToToken(address buyTokenAddress, address target, bytes swapCallData, uint256 feeAmount)", ""), + {0x3c, 0x74, 0xee, 0xd6}: w3.MustNewFunc("ActionInvalid(uint256 i, bytes4 action, bytes data)", ""), {0x3d, 0xd4, 0x5a, 0xdb}: w3.MustNewFunc("settleFor(address recipient)", "uint256 paid"), {0x3d, 0xf0, 0x21, 0x24}: w3.MustNewFunc("exchange(int128 i, int128 j, uint256 dx, uint256 min_dy)", ""), + {0x3e, 0xec, 0xe7, 0xdb}: w3.MustNewFunc("swap(address recipient, (uint256 amount, bool tokenAIn, bool exactOutput, int32 tickLimit) params, bytes data)", "uint256 amountIn, uint256 amountOut"), {0x3f, 0x44, 0x28, 0x64}: w3.MustNewFunc("swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, uint256 amountLimit, uint256 deadline, bytes data, uint256 trackingCode)", "int256 amount0, int256 amount1"), + {0x3f, 0x58, 0xe3, 0xcf}: w3.MustNewFunc("PoolSenderNotFactory(address sender, address accessor)", ""), + {0x3f, 0xc8, 0xce, 0xf3}: w3.MustNewFunc("weth()", "address"), {0x40, 0x2d, 0x26, 0x7d}: w3.MustNewFunc("maxDeposit(address receiver)", "uint256 maxAssets"), {0x40, 0xc1, 0x0f, 0x19}: w3.MustNewFunc("mint(address to, uint256 amount)", ""), {0x40, 0xd9, 0xc0, 0xe3}: w3.MustNewFunc("trim()", "uint256 wad"), @@ -97,31 +128,44 @@ var functions = map[[4]byte]*w3.Func{ {0x41, 0x4b, 0xf3, 0x89}: w3.MustNewFunc("exactInputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96) params)", "uint256 amountOut"), {0x42, 0x84, 0x2e, 0x0e}: w3.MustNewFunc("safeTransferFrom(address from, address to, uint256 tokenId)", ""), {0x42, 0x96, 0x6c, 0x68}: w3.MustNewFunc("burn(uint256)", ""), + {0x42, 0xe3, 0xd7, 0x2c}: w3.MustNewFunc("addLiquidity(address recipient, uint256 subaccount, (uint8 kind, int32[] ticks, uint128[] amounts) params, bytes data)", "uint256 tokenAAmount, uint256 tokenBAmount, uint32[] binIds"), + {0x44, 0x24, 0x0e, 0xfe}: w3.MustNewFunc("PoolTicksNotSorted(uint256 index, int256 previousTick, int256 tick)", ""), {0x45, 0xd6, 0x49, 0x4d}: w3.MustNewFunc("getBuyFee(uint256 grossAmount)", "uint256"), {0x46, 0x09, 0x85, 0xe8}: w3.MustNewFunc("swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, uint256 trackingCode)", "int256 amount0, int256 amount1"), {0x46, 0x0d, 0xd9, 0x49}: w3.MustNewFunc("settleBatch((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers)[] orders, (uint8 type, bytes signatureBytes)[] signatures, (bytes[] permitSignatures, bytes signatureBytesPermit2, uint48[] noncesPermit2, uint48 deadline)[] takersPermitsInfo, (bool result, address to, uint256 value, bytes data)[] interactions, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle)[] hooks, (address balanceRecipient, uint16[] curFillPercents, bool[] takersPermitsUsage, bool transferExactAmounts) solverData)", ""), {0x46, 0x14, 0x13, 0x19}: w3.MustNewFunc("feeGrowthGlobal1X128()", "uint256"), + {0x46, 0x8d, 0x01, 0x82}: w3.MustNewFunc("PoolKindNotSupported(uint256 kinds, uint256 kind)", ""), {0x47, 0xaa, 0xf0, 0x7a}: w3.MustNewFunc("SliceOverflow()", ""), {0x48, 0x3a, 0x69, 0x29}: w3.MustNewFunc("InvalidOwnerERC1155()", ""), {0x48, 0x5c, 0xc9, 0x55}: w3.MustNewFunc("initialize(address token0, address token1)", ""), {0x48, 0xc8, 0x94, 0x91}: w3.MustNewFunc("unlock(bytes data)", "bytes"), + {0x48, 0xfd, 0x65, 0xfe}: w3.MustNewFunc("tokenOfOwnerByIndexExists(address owner, uint256 index)", "bool"), {0x49, 0x0e, 0x6c, 0xbc}: w3.MustNewFunc("flash(address recipient, uint256 amount0, uint256 amount1, bytes data)", ""), {0x49, 0x3f, 0x4f, 0x74}: w3.MustNewFunc("get_address(uint256 idx)", "address"), + {0x49, 0x40, 0x4b, 0x7c}: w3.MustNewFunc("unwrapWETH9(uint256 amountMinimum, address recipient)", ""), + {0x49, 0x56, 0x86, 0x6a}: w3.MustNewFunc("RouterTooMuchRequested(uint256 amountInMaximum, uint256 amountIn)", ""), {0x4a, 0x24, 0x8d, 0x2a}: w3.MustNewFunc("_BASE_TOKEN_()", "address"), {0x4a, 0x25, 0xd9, 0x4a}: w3.MustNewFunc("swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] path, address to, uint256 deadline)", "uint256[] amounts"), {0x4a, 0x2a, 0xb3, 0xbe}: w3.MustNewFunc("get_y(uint256 ANN, uint256 gamma, uint256[3] x, uint256 D, uint256 i)", "uint256[2]"), + {0x4c, 0x08, 0x5b, 0xf1}: w3.MustNewFunc("DeltaNotPositive(address token)", ""), {0x4c, 0x84, 0xc1, 0xc8}: w3.MustNewFunc("wrapAll()", ""), + {0x4c, 0xc4, 0x42, 0x56}: w3.MustNewFunc("claimProtocolFeeForPool(address pool, bool isTokenA)", ""), {0x4c, 0xda, 0xd5, 0x06}: w3.MustNewFunc("previewRedeem(uint256 shares)", "uint256 assets"), {0x4d, 0xce, 0xbc, 0xba}: w3.MustNewFunc("swapSingle((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount)", ""), {0x4e, 0x48, 0x7b, 0x71}: w3.MustNewFunc("Panic(uint256)", ""), + {0x50, 0xfd, 0xc0, 0xac}: w3.MustNewFunc("PoolMigrateBinFirst()", ""), + {0x51, 0x49, 0xe7, 0x95}: w3.MustNewFunc("PayerSpent()", ""), {0x52, 0x75, 0x96, 0x51}: w3.MustNewFunc("updateDynamicLPFee((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint24 newDynamicLPFee)", ""), {0x52, 0xbb, 0xbe, 0x29}: w3.MustNewFunc("swap((bytes32 poolId, uint8 swapKind, address assetIn, address assetOut, uint256 amount, bytes data) singleSwap, (address sender, bool fromInternalBalance, address recipient, bool toInternalBalance) funds, uint256 limit, uint256 deadline)", "uint256"), {0x52, 0xc7, 0xf8, 0xdc}: w3.MustNewFunc("claimMintReward()", ""), + {0x52, 0xf7, 0xc9, 0x88}: w3.MustNewFunc("setFee(uint256 newFeeAIn, uint256 newFeeBIn)", ""), {0x54, 0x0d, 0x49, 0x18}: w3.MustNewFunc("lmPool()", "address"), {0x54, 0xfd, 0x4d, 0x50}: w3.MustNewFunc("version()", "uint256"), {0x55, 0xe4, 0xb7, 0xbe}: w3.MustNewFunc("fillQuoteTokenToToken(address sellTokenAddress, address buyTokenAddress, address target, bytes swapCallData, uint256 sellAmount, uint256 feeAmount)", ""), + {0x56, 0x85, 0x76, 0x42}: w3.MustNewFunc("accessor()", "address"), {0x57, 0x4f, 0x2b, 0xa3}: w3.MustNewFunc("allPairsLength()", "uint256"), {0x57, 0x5e, 0x24, 0xb4}: w3.MustNewFunc("beforeSwap(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96) params, bytes hookData)", "bytes4, int256, uint24"), + {0x57, 0x8e, 0xac, 0xa4}: w3.MustNewFunc("isFactoryPool(address pool)", "bool"), {0x59, 0x09, 0xc0, 0xd5}: w3.MustNewFunc("price0CumulativeLast()", "uint256"), {0x59, 0x21, 0xc8, 0xe0}: w3.MustNewFunc("burnAfterSeize(uint256 amount)", "uint256"), {0x5a, 0x3d, 0x54, 0x93}: w3.MustNewFunc("price1CumulativeLast()", "uint256"), @@ -129,6 +173,7 @@ var functions = map[[4]byte]*w3.Func{ {0x5b, 0x08, 0xba, 0x18}: w3.MustNewFunc("ERC721InvalidOperator(address operator)", ""), {0x5b, 0x0d, 0x59, 0x84}: w3.MustNewFunc("removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s)", "uint256 amountETH"), {0x5b, 0x41, 0xb9, 0x08}: w3.MustNewFunc("exchange(uint256 i, uint256 j, uint256 dx, uint256 min_dy)", ""), + {0x5b, 0xa9, 0x02, 0x10}: w3.MustNewFunc("createPermissioned(uint64 fee, uint16 tickSpacing, uint32 lookback, address tokenA, address tokenB, int32 activeTick, uint8 kinds, address accessor)", "address"), {0x5b, 0xcc, 0xb4, 0xc4}: w3.MustNewFunc("claimMintRewardAndStake(uint256 pct, uint256 term)", ""), {0x5b, 0xf6, 0xf9, 0x16}: w3.MustNewFunc("TransactionDeadlinePassed()", ""), {0x5c, 0x11, 0xd7, 0x95}: w3.MustNewFunc("swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline)", ""), @@ -143,32 +188,44 @@ var functions = map[[4]byte]*w3.Func{ {0x62, 0x76, 0xcb, 0xbe}: w3.MustNewFunc("initialize((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint160 sqrtPriceX96)", "int24 tick"), {0x63, 0x52, 0x21, 0x1e}: w3.MustNewFunc("ownerOf(uint256 tokenId)", "address"), {0x63, 0x70, 0xa8, 0x5c}: w3.MustNewFunc("curveTricryptoSwapCallback(address payer, address receiver, address sellToken, uint256 sellAmount, uint256 buyAmount)", ""), + {0x63, 0xfa, 0x28, 0x4a}: w3.MustNewFunc("RouterZeroSwap()", ""), {0x64, 0x28, 0x3d, 0x7b}: w3.MustNewFunc("ERC721IncorrectOwner(address sender, uint256 tokenId, address owner)", ""), + {0x64, 0x67, 0x7e, 0x32}: w3.MustNewFunc("claimProtocolFeeForPool(address pool)", ""), {0x64, 0xa0, 0xae, 0x92}: w3.MustNewFunc("ERC721InvalidReceiver(address receiver)", ""), {0x66, 0xa6, 0x5e, 0x41}: w3.MustNewFunc("settleMultiAndSignPermit2((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address[] takerTokens, address[] makerTokens, uint256[] takerAmounts, uint256[] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256[] makerAmounts, uint256 makerNonce) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint48 deadline, uint48[] nonces) infoPermit2)", ""), + {0x67, 0x0c, 0xa1, 0x81}: w3.MustNewFunc("unwrapAndSweep(address tokenA, address tokenB, uint256 tokenAAmountMin, uint256 tokenBAmountMin)", ""), {0x67, 0x1c, 0x21, 0x15}: w3.MustNewFunc("fillRfqOrderVIP(address recipient, (address token, uint256 amount, uint256 nonce, uint256 deadline) makerPermit, address maker, bytes makerSig, (address token, uint256 amount, uint256 nonce, uint256 deadline) takerPermit, bytes takerSig)", ""), {0x67, 0x5c, 0xae, 0x38}: w3.MustNewFunc("InsufficientToken()", ""), + {0x67, 0x9f, 0x05, 0x79}: w3.MustNewFunc("flashLoan(address recipient, uint256 amountA, uint256 amountB, bytes data)", "uint128 lendingFeeA, uint128 lendingFeeB"), {0x67, 0xca, 0x7c, 0x91}: w3.MustNewFunc("maverickV2SwapCallback(address tokenIn, uint256 amountIn, uint256 amountOut, bytes data)", ""), {0x69, 0x62, 0xf8, 0x45}: w3.MustNewFunc("mint_relative(address to, uint256 frac)", "uint256"), {0x6a, 0x12, 0xf1, 0x04}: w3.MustNewFunc("InsufficientETH()", ""), {0x6c, 0x2b, 0xbe, 0x7e}: w3.MustNewFunc("afterRemoveLiquidity(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, int256 delta, int256 feesAccrued, bytes hookData)", "bytes4, int256"), {0x6d, 0x54, 0x33, 0xe6}: w3.MustNewFunc("max(uint256, uint256)", "uint256"), {0x6e, 0x55, 0x3f, 0x65}: w3.MustNewFunc("deposit(uint256 assets, address receiver)", "uint256 shares"), + {0x6e, 0x99, 0x60, 0xc3}: w3.MustNewFunc("getAdmin()", "address"), {0x6f, 0x5f, 0xfb, 0x7e}: w3.MustNewFunc("ContractLocked()", ""), {0x6f, 0xe7, 0xe6, 0xeb}: w3.MustNewFunc("afterInitialize(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint160 sqrtPriceX96, int24 tick)", "bytes4"), + {0x70, 0x4b, 0x6c, 0x02}: w3.MustNewFunc("setAdmin(address newAdmin)", ""), {0x70, 0xa0, 0x82, 0x31}: w3.MustNewFunc("balanceOf(address)", "uint256"), {0x71, 0x50, 0x18, 0xa6}: w3.MustNewFunc("renounceOwnership()", ""), {0x72, 0x84, 0xe4, 0x16}: w3.MustNewFunc("description()", "string"), {0x72, 0xfc, 0x32, 0xe5}: w3.MustNewFunc("settleAggregateAndSignPermit2((uint256 expiry, address takerAddress, address[] makerAddresses, uint256[] makerNonces, address[][] takerTokens, address[][] makerTokens, uint256[][] takerAmounts, uint256[][] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags)[] makersSignatures, uint256 filledTakerAmount, (bool useOldAmount, uint256[][] makerAmounts, uint256[] makerNonces) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint48 deadline, uint48[] nonces) infoPermit2)", ""), {0x73, 0x9d, 0xbe, 0x52}: w3.MustNewFunc("V3TooMuchRequested()", ""), {0x73, 0xc6, 0xac, 0x6e}: w3.MustNewFunc("ERC721InvalidSender(address sender)", ""), + {0x74, 0x07, 0xc0, 0xf8}: w3.MustNewFunc("ReentrantPayer(address oldPayer)", ""), + {0x74, 0x4e, 0xbf, 0xd6}: w3.MustNewFunc("kinds()", "uint8 kinds"), {0x74, 0x64, 0xfc, 0x3d}: w3.MustNewFunc("kLast()", "uint256"), {0x75, 0x19, 0xab, 0x50}: w3.MustNewFunc("updatedAt()", "uint256"), + {0x75, 0x1d, 0xf1, 0x7a}: w3.MustNewFunc("checkAuthorized(address spender, uint256 tokenId)", "address owner"), {0x75, 0x4b, 0x76, 0xb3}: w3.MustNewFunc("get_p(uint256[3] xp, uint256 D, uint256[2] A_gamma)", "uint256[2]"), + {0x75, 0x79, 0x4a, 0x3c}: w3.MustNewFunc("nextTokenId()", "uint256 nextTokenId_"), {0x75, 0xd3, 0x9e, 0xcb}: w3.MustNewFunc("swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, uint256 amountLimit, uint256 deadline)", "int256 amount0, int256 amount1"), {0x77, 0x14, 0x6e, 0x62}: w3.MustNewFunc("ToAddressOverflow()", ""), + {0x78, 0x4c, 0xb7, 0xb8}: w3.MustNewFunc("BoughtSellToken(address sellToken)", ""), {0x79, 0x1a, 0xc9, 0x47}: w3.MustNewFunc("swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline)", ""), {0x79, 0xcc, 0x67, 0x90}: w3.MustNewFunc("burnFrom(address to, uint256 value)", "bool"), + {0x7a, 0xab, 0xf4, 0x53}: w3.MustNewFunc("lendingFeeRateD18()", "uint256"), {0x7a, 0xe2, 0xb5, 0xc7}: w3.MustNewFunc("min(uint256, uint256)", "uint256"), {0x7b, 0x04, 0x72, 0xf0}: w3.MustNewFunc("stake(uint256 amount, uint256 term)", ""), {0x7b, 0x12, 0xe0, 0x09}: w3.MustNewFunc("newton_D(uint256 ANN, uint256 gamma, uint256[3] x_unsorted, uint256 K0_prev)", "uint256"), @@ -183,41 +240,64 @@ var functions = map[[4]byte]*w3.Func{ {0x81, 0x61, 0xb8, 0x74}: w3.MustNewFunc("collectProtocolFees(address recipient, address currency, uint256 amount)", "uint256 amountCollected"), {0x81, 0xd1, 0x8d, 0x87}: w3.MustNewFunc("wad_exp(int256 power)", "uint256"), {0x82, 0x5c, 0xab, 0xa1}: w3.MustNewFunc("cancelOrderRFQ(uint256 orderInfo)", ""), + {0x82, 0xd5, 0xd7, 0x6a}: w3.MustNewFunc("InvalidTarget()", ""), {0x83, 0xc4, 0xa1, 0x9d}: w3.MustNewFunc("swapTargets(address)", "bool"), {0x84, 0x9e, 0xaf, 0x98}: w3.MustNewFunc("V2TooLittleReceived()", ""), + {0x84, 0xae, 0x11, 0x48}: w3.MustNewFunc("RouterTooLittleReceived(uint256 amountOutMinimum, uint256 amountOut)", ""), + {0x85, 0x42, 0x66, 0x37}: w3.MustNewFunc("PoolInsufficientBalance(uint256 deltaLpAmount, uint256 accountBalance)", ""), {0x85, 0x58, 0x59, 0xb4}: w3.MustNewFunc("ToUint24Overflow()", ""), {0x85, 0xf8, 0xc2, 0x59}: w3.MustNewFunc("getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut)", "uint256 amountIn"), + {0x86, 0x6e, 0x44, 0xb6}: w3.MustNewFunc("deployParameters()", "uint64 feeAIn, uint64 feeBIn, uint32 lookback, int32 activeTick, uint64 tokenAScale, uint64 tokenBScale, address tokenA, address tokenB, uint16 tickSpacing, uint8 options, address accessor"), + {0x86, 0xc3, 0x4f, 0x42}: w3.MustNewFunc("sellGemNoFee(address usr, uint256 gemAmt)", "uint256 daiOutWad"), {0x87, 0x52, 0x8f, 0x13}: w3.MustNewFunc("settle((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, (bool result, address to, uint256 value, bytes data)[] interactions, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (address balanceRecipient, uint16 curFillPercent) solverData)", ""), {0x88, 0x03, 0xdb, 0xee}: w3.MustNewFunc("swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] path, address to, uint256 deadline)", "uint256[] amounts"), {0x88, 0x1e, 0xb1, 0x4e}: w3.MustNewFunc("gush()", "uint256 wad"), + {0x88, 0x24, 0x37, 0xfa}: w3.MustNewFunc("lookupPermissioned(uint256 startIndex, uint256 endIndex)", "address[] pools"), + {0x89, 0x39, 0x6d, 0xc8}: w3.MustNewFunc("getImplementationSigs(address impl)", "bytes4[]"), {0x89, 0xc6, 0x2b, 0x64}: w3.MustNewFunc("ERC721InvalidOwner(address owner)", ""), + {0x8a, 0x52, 0xcc, 0xc2}: w3.MustNewFunc("poolPermissionedCount()", "uint256 _poolCount"), {0x8a, 0xb0, 0xbc, 0x16}: w3.MustNewFunc("V2TooMuchRequested()", ""), + {0x8c, 0x25, 0x25, 0xfe}: w3.MustNewFunc("PoolSenderNotAccessor(address sender, address accessor)", ""), {0x8d, 0x7e, 0xf9, 0xbb}: w3.MustNewFunc("buyGem(address usr, uint256 gemAmt)", "uint256 daiInWad"), {0x8d, 0xa5, 0xcb, 0x5b}: w3.MustNewFunc("owner()", "address"), + {0x8e, 0x54, 0x30, 0xa7}: w3.MustNewFunc("migrateBinUpStack(uint32 binId, uint32 maxRecursion)", ""), {0x90, 0x10, 0xd0, 0x7c}: w3.MustNewFunc("getRoleMember(bytes32 role, uint256 index)", "address"), + {0x90, 0x26, 0xb8, 0xbc}: w3.MustNewFunc("protocolFeeB()", "uint128"), + {0x90, 0x8b, 0xfe, 0x5e}: w3.MustNewFunc("getDummyImplementation()", "address"), {0x90, 0x93, 0xbf, 0x7b}: w3.MustNewFunc("settleAggregateAndSignPermit((uint256 expiry, address takerAddress, address[] makerAddresses, uint256[] makerNonces, address[][] takerTokens, address[][] makerTokens, uint256[][] takerAmounts, uint256[][] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags)[] makersSignatures, uint256 filledTakerAmount, (bool useOldAmount, uint256[][] makerAmounts, uint256[] makerNonces) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint256 deadline) takerPermitSignature)", ""), {0x91, 0xd1, 0x48, 0x54}: w3.MustNewFunc("hasRole(bytes32 role, address account)", "bool"), {0x92, 0x7d, 0xa1, 0x05}: w3.MustNewFunc("allowance(address user, address token, address spender)", "uint160 amount, uint48 expiration, uint48 nonce"), + {0x93, 0x29, 0x34, 0x0d}: w3.MustNewFunc("binIdByTickKind(int32 tick, uint256 kind)", "uint32"), {0x94, 0x28, 0x0d, 0x62}: w3.MustNewFunc("ERC20InvalidSpender(address spender)", ""), {0x94, 0x5b, 0xce, 0xc9}: w3.MustNewFunc("batchSwap(uint8 swapKind, (bytes32 poolId, uint256 assetInIndex, uint256 assetOutIndex, uint256 amount, bytes data)[] swaps, address[] assets, (address sender, bool fromInternalBalance, address recipient, bool toInternalBalance) funds, int256[] limits, uint256 deadline)", "int256[]"), {0x94, 0xbf, 0x80, 0x4d}: w3.MustNewFunc("mint(uint256 shares, address receiver)", "uint256 assets"), + {0x94, 0xe2, 0x45, 0xe4}: w3.MustNewFunc("PoolInvalidFee()", ""), {0x95, 0x4c, 0x1c, 0x0d}: w3.MustNewFunc("buyAssetWithSig(address originator, uint256 minAmount, address receiver, uint256 deadline, bytes signature)", "uint256, uint256"), {0x95, 0x7a, 0xa5, 0x8c}: w3.MustNewFunc("live()", "uint256"), {0x95, 0x99, 0x12, 0x76}: w3.MustNewFunc("sellGem(address usr, uint256 gemAmt)", "uint256 daiOutWad"), {0x95, 0x9d, 0x6d, 0x29}: w3.MustNewFunc("getSellFee(uint256 grossAmount)", "uint256"), {0x95, 0xd8, 0x9b, 0x41}: w3.MustNewFunc("symbol()", "string"), {0x96, 0xc6, 0xfd, 0x1e}: w3.MustNewFunc("ERC20InvalidSender(address sender)", ""), + {0x97, 0xa6, 0xf3, 0xb9}: w3.MustNewFunc("TooMuchSlippage(address token, uint256 expected, uint256 actual)", ""), {0x97, 0xbb, 0xda, 0x0e}: w3.MustNewFunc("updateSwapTargets(address target, bool add)", ""), {0x97, 0xe8, 0xcd, 0x4e}: w3.MustNewFunc("protocolFeesAccrued(address currency)", "uint256 amount"), + {0x98, 0xde, 0x5e, 0x75}: w3.MustNewFunc("PoolMinimumLiquidityNotMet()", ""), + {0x99, 0x01, 0x3a, 0xa8}: w3.MustNewFunc("permissionedLiquidity()", "bool permissionedLiquidity"), + {0x99, 0x36, 0xcb, 0xab}: w3.MustNewFunc("ReentrantMetatransaction(bytes32 oldWitness)", ""), + {0x99, 0x6b, 0x74, 0x0a}: w3.MustNewFunc("InvalidCurve(uint256 x, uint256 y)", ""), {0x99, 0x9b, 0x64, 0x64}: w3.MustNewFunc("fillQuoteTokenToEth(address sellTokenAddress, address target, bytes swapCallData, uint256 sellAmount, uint256 feePercentageBasisPoints)", ""), + {0x9a, 0x62, 0xe8, 0xb4}: w3.MustNewFunc("TokenHashCollision(address token0, address token1)", ""), {0x9a, 0x6f, 0xc8, 0xf5}: w3.MustNewFunc("getRoundData(uint80 roundId)", "uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound"), {0x9b, 0x65, 0x2d, 0xf6}: w3.MustNewFunc("chug()", "uint256 wad"), {0x9b, 0xe2, 0xa8, 0x84}: w3.MustNewFunc("canPerform(bytes32 actionId, address account, address where)", "bool"), {0x9b, 0xf6, 0x64, 0x5f}: w3.MustNewFunc("exttload(bytes32[] slots)", "bytes32[] values"), {0x9d, 0xc2, 0x9f, 0xac}: w3.MustNewFunc("burn(address user, uint256 amount)", ""), + {0x9d, 0xc6, 0xcc, 0xae}: w3.MustNewFunc("updateProtocolFeeRatioForPool(address pool)", ""), + {0x9e, 0x59, 0xe5, 0x98}: w3.MustNewFunc("tokenIdsOfOwner(address owner)", "uint256[] tokenIds"), {0x9f, 0x06, 0x3e, 0xfc}: w3.MustNewFunc("afterAddLiquidity(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, int256 delta, int256 feesAccrued, bytes hookData)", "bytes4, int256"), {0xa0, 0x71, 0x2d, 0x68}: w3.MustNewFunc("mint(uint256)", ""), {0xa1, 0x6f, 0x5f, 0xd2}: w3.MustNewFunc("cumulativeSum()", "uint256"), + {0xa1, 0xe2, 0x81, 0x50}: w3.MustNewFunc("PoolTickMaxExceeded(uint256 tick)", ""), {0xa2, 0x2c, 0xb4, 0x65}: w3.MustNewFunc("setApprovalForAll(address operator, bool approved)", ""), {0xa2, 0x3b, 0xa0, 0x9c}: w3.MustNewFunc("swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, uint256 amountLimit, uint256 deadline, uint256 trackingCode)", "int256 amount0, int256 amount1"), {0xa2, 0x62, 0x90, 0x4b}: w3.MustNewFunc("get_registry()", "address"), @@ -226,6 +306,7 @@ var functions = map[[4]byte]*w3.Func{ {0xa4, 0x98, 0x46, 0x33}: w3.MustNewFunc("crossLmTick(int24 tick, bool zeroForOne)", ""), {0xa4, 0xa2, 0x1f, 0xa2}: w3.MustNewFunc("getGrossAmountFromTotalBought(uint256 totalAmount)", "uint256"), {0xa5, 0x84, 0x11, 0x94}: w3.MustNewFunc("sync(address currency)", ""), + {0xa5, 0xfc, 0xc8, 0xbc}: w3.MustNewFunc("getSigsImplementation(bytes4 sig)", "address"), {0xa6, 0x41, 0x7e, 0xd6}: w3.MustNewFunc("exchange_underlying(int128 i, int128 j, uint256 dx, uint256 min_dy)", ""), {0xa7, 0x8a, 0xa2, 0x7f}: w3.MustNewFunc("ToAddressOutOfBounds()", ""), {0xa7, 0xb7, 0x8c, 0x3c}: w3.MustNewFunc("getAssetPriceInGho(uint256 assetAmount, bool roundUp)", "uint256"), @@ -233,6 +314,10 @@ var functions = map[[4]byte]*w3.Func{ {0xa9, 0xfb, 0xf5, 0x1f}: w3.MustNewFunc("ERC721InvalidApprover(address approver)", ""), {0xaa, 0x44, 0x3a, 0xc0}: w3.MustNewFunc("sellAsset(uint256 maxAmount, address receiver)", "uint256, uint256"), {0xaa, 0xab, 0xad, 0xc5}: w3.MustNewFunc("getAuthorizer()", "address"), + {0xab, 0x76, 0x46, 0xc4}: w3.MustNewFunc("ReentrantCallback(uint256 callbackInt)", ""), + {0xac, 0x67, 0xa9, 0x47}: w3.MustNewFunc("PoolCurrentTickBeyondSwapLimit(int32 startingTick)", ""), + {0xac, 0x96, 0x50, 0xd8}: w3.MustNewFunc("multicall(bytes[] data)", "bytes[] results"), + {0xad, 0x19, 0x91, 0xf5}: w3.MustNewFunc("ZeroToken()", ""), {0xad, 0x5c, 0x46, 0x48}: w3.MustNewFunc("WETH()", "address"), {0xad, 0x61, 0x5d, 0xec}: w3.MustNewFunc("quote(uint256 amountA, uint256 reserveA, uint256 reserveB)", "uint256 amountB"), {0xae, 0x52, 0xad, 0x0c}: w3.MustNewFunc("V2InvalidPath()", ""), @@ -245,9 +330,13 @@ var functions = map[[4]byte]*w3.Func{ {0xb3, 0xd7, 0xf6, 0xb9}: w3.MustNewFunc("previewMint(uint256 shares)", "uint256 assets"), {0xb4, 0x60, 0xaf, 0x94}: w3.MustNewFunc("withdraw(uint256 assets, address receiver, address owner)", "uint256 shares"), {0xb4, 0x7b, 0x2f, 0xb1}: w3.MustNewFunc("afterSwap(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96) params, int256 delta, bytes hookData)", "bytes4, int128"), + {0xb4, 0xb9, 0xd1, 0xf1}: w3.MustNewFunc("lookup(uint256 startIndex, uint256 endIndex)", "address[] pools"), + {0xb4, 0xc9, 0x91, 0xc6}: w3.MustNewFunc("poolByTokenCount(address _tokenA, address _tokenB, address accessor)", "uint256 _poolCount"), + {0xb5, 0xc7, 0x36, 0xe4}: w3.MustNewFunc("readFromStorage(bytes32 slot)", "uint256 result"), {0xb6, 0xa8, 0xb0, 0xfa}: w3.MustNewFunc("beforeDonate(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint256 amount0, uint256 amount1, bytes hookData)", "bytes4"), {0xb6, 0xf9, 0xde, 0x95}: w3.MustNewFunc("swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] path, address to, uint256 deadline)", ""), {0xb8, 0x8d, 0x4f, 0xde}: w3.MustNewFunc("safeTransferFrom(address from, address to, uint256 tokenId, bytes data)", ""), + {0xb9, 0x48, 0x0d, 0x4a}: w3.MustNewFunc("protocolFeeA()", "uint128"), {0xba, 0x08, 0x76, 0x52}: w3.MustNewFunc("redeem(uint256 shares, address receiver, address owner)", "uint256 assets"), {0xba, 0x9a, 0x7a, 0x56}: w3.MustNewFunc("MINIMUM_LIQUIDITY()", "uint256"), {0xba, 0xa2, 0xab, 0xde}: w3.MustNewFunc("removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline)", "uint256 amountA, uint256 amountB"), @@ -257,8 +346,11 @@ var functions = map[[4]byte]*w3.Func{ {0xbd, 0x60, 0x15, 0xb4}: w3.MustNewFunc("sellBase(address to)", "uint256 receiveQuoteAmount"), {0xbe, 0x00, 0xbb, 0xd8}: w3.MustNewFunc("getApp(bytes32 namespace, bytes32 appId)", "address"), {0xc0, 0x4b, 0x8d, 0x59}: w3.MustNewFunc("exactInput((bytes path, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum) params)", "uint256 amountOut"), + {0xc1, 0x58, 0x3f, 0x2c}: w3.MustNewFunc("PoolReservesExceedMaximum(uint256 amount)", ""), {0xc3, 0x1b, 0x8d, 0x7a}: w3.MustNewFunc("swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96)", "int256 amount0, int256 amount1"), + {0xc3, 0x21, 0x52, 0x6c}: w3.MustNewFunc("InvalidSignatureLen()", ""), {0xc3, 0x8a, 0x44, 0x74}: w3.MustNewFunc("swapSingleFromContract((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature)", ""), + {0xc3, 0x9a, 0xa0, 0x7d}: w3.MustNewFunc("setDummyImplementation(address newDummyImplementation)", ""), {0xc4, 0x5a, 0x01, 0x55}: w3.MustNewFunc("factory()", "address"), {0xc4, 0xbd, 0x89, 0xa9}: w3.MustNewFunc("UnsafeCast()", ""), {0xc6, 0x3d, 0x75, 0xb6}: w3.MustNewFunc("maxMint(address receiver)", "uint256 maxShares"), @@ -268,8 +360,11 @@ var functions = map[[4]byte]*w3.Func{ {0xc9, 0xc6, 0x53, 0x96}: w3.MustNewFunc("createPair(address tokenA, address tokenB)", "address pair"), {0xca, 0x15, 0xc8, 0x73}: w3.MustNewFunc("getRoleMemberCount(bytes32 role)", "uint256"), {0xca, 0xb4, 0x6b, 0xc6}: w3.MustNewFunc("setSwapFreeze(bool enable)", ""), + {0xca, 0xbc, 0x4f, 0x38}: w3.MustNewFunc("PoolTicksAmountsLengthMismatch(uint256 ticksLength, uint256 amountsLength)", ""), {0xcb, 0xf0, 0xbf, 0xac}: w3.MustNewFunc("rush()", "uint256 wad"), + {0xcb, 0xf0, 0xdb, 0xf5}: w3.MustNewFunc("ZeroBuyAmount(address buyToken)", ""), {0xcc, 0x94, 0xa6, 0x3a}: w3.MustNewFunc("NoSlice()", ""), + {0xcd, 0x21, 0xdb, 0x4f}: w3.MustNewFunc("SignatureExpired(uint256 deadline)", ""), {0xce, 0x7d, 0x65, 0x03}: w3.MustNewFunc("exchange(uint256 i, uint256 j, uint256 dx, uint256 min_dy, bool use_eth, address receiver)", "uint256"), {0xce, 0x96, 0xcb, 0x77}: w3.MustNewFunc("maxWithdraw(address owner)", "uint256 maxAssets"), {0xce, 0xa9, 0xd2, 0x6f}: w3.MustNewFunc("rescueTokens(address token, address to, uint256 amount)", ""), @@ -277,60 +372,83 @@ var functions = map[[4]byte]*w3.Func{ {0xd0, 0xa3, 0xb6, 0x65}: w3.MustNewFunc("fillOrderRFQ((uint256 info, address makerAsset, address takerAsset, address maker, address allowedSender, uint256 makingAmount, uint256 takingAmount) order, bytes signature, uint256 makingAmount, uint256 takingAmount)", ""), {0xd0, 0xc9, 0x3a, 0x7c}: w3.MustNewFunc("tickSpacing()", "int24"), {0xd0, 0xe3, 0x0d, 0xb0}: w3.MustNewFunc("deposit()", ""), + {0xd1, 0x11, 0x23, 0xd8}: w3.MustNewFunc("lookupPermissioned(uint256 feeAIn, uint256 feeBIn, uint256 tickSpacing, uint256 lookback, address tokenA, address tokenB, uint8 options, address accessor)", "address"), {0xd2, 0x12, 0x20, 0xa7}: w3.MustNewFunc("token1()", "address"), + {0xd3, 0xb1, 0x27, 0x6d}: w3.MustNewFunc("UnknownForkId(uint8 forkId)", ""), + {0xd3, 0xd3, 0x86, 0x1a}: w3.MustNewFunc("getCurrentTwa()", "int256"), {0xd4, 0xb9, 0x70, 0x46}: w3.MustNewFunc("_QUOTE_TOKEN_()", "address"), {0xd4, 0xe0, 0x24, 0x8e}: w3.MustNewFunc("V3InvalidAmountOut()", ""), {0xd5, 0x05, 0xac, 0xcf}: w3.MustNewFunc("permit(address owner, address spender, uint256 amount, uint256 deadline, uint8 v, bytes32 r, bytes32 s)", ""), {0xd5, 0x47, 0x74, 0x1f}: w3.MustNewFunc("revokeRole(bytes32 role, address account)", ""), + {0xd5, 0xde, 0x4f, 0x43}: w3.MustNewFunc("PoolBinIdsAmountsLengthMismatch(uint256 binIdsLength, uint256 amountsLength)", ""), + {0xd6, 0x6f, 0xcc, 0x38}: w3.MustNewFunc("CallbackNotSpent(uint256 callbackInt)", ""), {0xd7, 0x6a, 0x1e, 0x9e}: w3.MustNewFunc("InvalidCommandType(uint256 commandType)", ""), {0xd9, 0x05, 0x77, 0x7e}: w3.MustNewFunc("maxRedeem(address owner)", "uint256 maxShares"), {0xd9, 0x09, 0x6a, 0x3e}: w3.MustNewFunc("ToUint24OutOfBounds()", ""), + {0xd9, 0x2e, 0x23, 0x3d}: w3.MustNewFunc("ZeroAddress()", ""), {0xd9, 0xc5, 0x5c, 0xe1}: w3.MustNewFunc("fill()", "uint256 wad"), + {0xda, 0xfc, 0x3d, 0xb1}: w3.MustNewFunc("lookup(uint256 feeAIn, uint256 feeBIn, uint256 tickSpacing, uint256 lookback, address tokenA, address tokenB, uint8 kinds)", "address"), {0xdb, 0x3e, 0x21, 0x98}: w3.MustNewFunc("exactOutputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountOut, uint256 amountInMaximum, uint160 sqrtPriceLimitX96) params)", "uint256 amountIn"), {0xdb, 0xd0, 0x35, 0xff}: w3.MustNewFunc("extsload(bytes32[] slots)", "bytes32[] values"), {0xdc, 0x98, 0x35, 0x4e}: w3.MustNewFunc("beforeInitialize(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint160 sqrtPriceX96)", "bytes4"), {0xdd, 0x62, 0xed, 0x3e}: w3.MustNewFunc("allowance(address owner, address spender)", "uint256"), {0xdd, 0x93, 0xf5, 0x9a}: w3.MustNewFunc("sellQuote(address to)", "uint256 receiveBaseAmount"), {0xdd, 0x96, 0x99, 0x4f}: w3.MustNewFunc("exchange_extended(uint256 sellIndex, uint256 buyIndex, uint256 sellAmount, uint256 minBuyAmount, bool useEth, address payer, address receiver, bytes32 callbackSelector)", "uint256 buyAmount"), + {0xdd, 0xb5, 0xde, 0x5e}: w3.MustNewFunc("InvalidSender()", ""), {0xdd, 0xc1, 0xf5, 0x9d}: w3.MustNewFunc("exchange(int128 i, int128 j, uint256 dx, uint256 min_dy, address receiver)", ""), {0xdd, 0xca, 0x3f, 0x43}: w3.MustNewFunc("fee()", "uint24"), {0xde, 0x28, 0x73, 0x59}: w3.MustNewFunc("acl()", "address"), {0xde, 0xaa, 0x01, 0xe6}: w3.MustNewFunc("InvalidBips()", ""), {0xde, 0xd9, 0x38, 0x2a}: w3.MustNewFunc("removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s)", "uint256 amountToken, uint256 amountETH"), + {0xdf, 0x2a, 0xb5, 0xbb}: w3.MustNewFunc("sweepToken(address token, uint256 amountMinimum, address recipient)", ""), {0xe1, 0xb4, 0xaf, 0x69}: w3.MustNewFunc("afterDonate(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint256 amount0, uint256 amount1, bytes hookData)", "bytes4"), + {0xe2, 0x55, 0x27, 0xc2}: w3.MustNewFunc("WitnessNotSpent(bytes32 oldWitness)", ""), + {0xe2, 0x62, 0x79, 0x0d}: w3.MustNewFunc("lookup(address _tokenA, address _tokenB, uint256 startIndex, uint256 endIndex)", "address[] pools"), {0xe4, 0x49, 0x02, 0x2e}: w3.MustNewFunc("uniswapV3Swap(uint256 amount, uint256 minReturn, uint256[] pools)", "uint256 returnAmount"), {0xe4, 0x50, 0xd3, 0x8c}: w3.MustNewFunc("ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed)", ""), + {0xe5, 0x59, 0xab, 0xbf}: w3.MustNewFunc("create(uint64 fee, uint16 tickSpacing, uint32 lookback, address tokenA, address tokenB, int32 activeTick, uint8 kinds)", "address"), {0xe6, 0x02, 0xdf, 0x05}: w3.MustNewFunc("ERC20InvalidApprover(address approver)", ""), {0xe6, 0xa4, 0x39, 0x05}: w3.MustNewFunc("getPair(address tokenA, address tokenB)", "address pair"), {0xe6, 0xfd, 0x60, 0x4c}: w3.MustNewFunc("cut()", "uint256 wad"), {0xe7, 0x00, 0x28, 0x77}: w3.MustNewFunc("FromAddressIsNotOwner()", ""), + {0xe7, 0x58, 0xb8, 0xd5}: w3.MustNewFunc("ConfusedDeputy()", ""), {0xe8, 0xe3, 0x37, 0x00}: w3.MustNewFunc("addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline)", "uint256 amountA, uint256 amountB, uint256 liquidity"), {0xe9, 0x85, 0xe9, 0xc5}: w3.MustNewFunc("isApprovedForAll(address owner, address operator)", "bool"), {0xeb, 0x8d, 0x21, 0x16}: w3.MustNewFunc("transferTokens((address from, address receiver, address[] tokens, uint256[] amounts, uint256[] nftIds, bytes tokenTransferTypes, uint16 fillPercent) transferData)", ""), + {0xeb, 0xcb, 0xd2, 0x81}: w3.MustNewFunc("lookback()", "uint256"), {0xec, 0x44, 0x2f, 0x05}: w3.MustNewFunc("ERC20InvalidReceiver(address receiver)", ""), {0xec, 0x98, 0x37, 0x76}: w3.MustNewFunc("settleWithPermitsSignatures((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, (bytes[] permitSignatures, bytes signatureBytesPermit2, uint48[] noncesPermit2, uint48 deadline) takerPermitsInfo, (bool result, address to, uint256 value, bytes data)[] interactions, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (address balanceRecipient, uint16 curFillPercent) solverData)", ""), {0xef, 0x7d, 0x27, 0xad}: w3.MustNewFunc("settleSingleAndSignPermit((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256 makerAmount, uint256 makerNonce) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint256 deadline) takerPermitSignature)", ""), {0xef, 0x8b, 0x30, 0xf7}: w3.MustNewFunc("previewDeposit(uint256 assets)", "uint256 shares"), {0xef, 0xe3, 0x4f, 0xe6}: w3.MustNewFunc("settleMulti((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address[] takerTokens, address[] makerTokens, uint256[] takerAmounts, uint256[] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256[] makerAmounts, uint256 makerNonce) takerQuoteInfo, bytes takerSignature)", ""), {0xf0, 0x2d, 0xe3, 0xb2}: w3.MustNewFunc("protocolFeeController()", "address"), + {0xf0, 0xc0, 0x1b, 0x42}: w3.MustNewFunc("addImplementation(address implementation, bytes4[] sigs)", ""), {0xf1, 0x35, 0xba, 0xaa}: w3.MustNewFunc("exttload(bytes32 slot)", "bytes32 value"), + {0xf1, 0x6d, 0x79, 0x04}: w3.MustNewFunc("sweepTokenAmount(address token, uint256 amount, address recipient)", ""), {0xf2, 0x8c, 0x04, 0x98}: w3.MustNewFunc("exactOutput((bytes path, address recipient, uint256 deadline, uint256 amountOut, uint256 amountInMaximum) params)", "uint256 amountIn"), {0xf2, 0xfd, 0xe3, 0x8b}: w3.MustNewFunc("transferOwnership(address newOwner)", ""), {0xf3, 0x05, 0x83, 0x99}: w3.MustNewFunc("feeGrowthGlobal0X128()", "uint256"), {0xf3, 0x05, 0xd7, 0x19}: w3.MustNewFunc("addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline)", "uint256 amountToken, uint256 amountETH, uint256 liquidity"), {0xf4, 0x2c, 0x56, 0xc2}: w3.MustNewFunc("cbrt(uint256 x)", "uint256"), {0xf4, 0x93, 0xca, 0x70}: w3.MustNewFunc("sellAssetWithSig(address originator, uint256 maxAmount, address receiver, uint256 deadline, bytes signature)", "uint256, uint256"), + {0xf4, 0xb5, 0x24, 0x83}: w3.MustNewFunc("create(uint64 feeAIn, uint64 feeBIn, uint16 tickSpacing, uint32 lookback, address tokenA, address tokenB, int32 activeTick, uint8 kinds)", "address"), + {0xf5, 0x25, 0xcb, 0x68}: w3.MustNewFunc("poolCount()", "uint256 _poolCount"), {0xf5, 0x29, 0x8a, 0xca}: w3.MustNewFunc("burn(address from, uint256 id, uint256 amount)", ""), + {0xf8, 0x48, 0xd4, 0x9d}: w3.MustNewFunc("PoolZeroLiquidityAdded()", ""), {0xf8, 0x51, 0xa4, 0x40}: w3.MustNewFunc("admin()", "address"), + {0xf9, 0x57, 0xf1, 0xca}: w3.MustNewFunc("removeLiquidity(address recipient, uint256 subaccount, (uint32[] binIds, uint128[] amounts) params)", "uint256 tokenAOut, uint256 tokenBOut"), + {0xf9, 0x81, 0x75, 0xc4}: w3.MustNewFunc("balanceOf(address user, uint256 subaccount, uint32 binId)", "uint128 lpToken"), {0xfa, 0x18, 0x04, 0x2d}: w3.MustNewFunc("reduction_coefficient(uint256[3] x, uint256 fee_gamma)", "uint256"), {0xfa, 0x46, 0x1e, 0x33}: w3.MustNewFunc("uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes data)", ""), {0xfa, 0x6e, 0x67, 0x1d}: w3.MustNewFunc("setRelayerApproval(address sender, address relayer, bool approved)", ""), {0xfa, 0xe0, 0x36, 0xd5}: w3.MustNewFunc("tout()", "uint256"), {0xfb, 0x3b, 0xdb, 0x41}: w3.MustNewFunc("swapETHForExactTokens(uint256 amountOut, address[] path, address to, uint256 deadline)", "uint256[] amounts"), + {0xfb, 0x77, 0x2a, 0x88}: w3.MustNewFunc("ZeroSellAmount(address token)", ""), {0xfb, 0x8f, 0x41, 0xb2}: w3.MustNewFunc("ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed)", ""), {0xfc, 0x0c, 0x54, 0x6a}: w3.MustNewFunc("token()", "address"), {0xfd, 0xef, 0x91, 0x06}: w3.MustNewFunc("hasPermission(address who, address where, bytes32 what, bytes how)", "bool"), {0xfe, 0xaf, 0x96, 0x8c}: w3.MustNewFunc("latestRoundData()", "uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound"), {0xfe, 0xc9, 0x0d, 0x72}: w3.MustNewFunc("hasApprovedRelayer(address user, address relayer)", "bool"), + {0xff, 0x63, 0x3a, 0x38}: w3.MustNewFunc("LengthMismatch()", ""), {0xff, 0xf6, 0xca, 0xe9}: w3.MustNewFunc("sync()", ""), } diff --git a/internal/fourbyte/funcs.txt b/internal/fourbyte/funcs.txt index 8d429483..338bfe64 100644 --- a/internal/fourbyte/funcs.txt +++ b/internal/fourbyte/funcs.txt @@ -1,7 +1,11 @@ _BASE_TOKEN_() address _QUOTE_TOKEN_() address +accessor() address accumulateReward(uint32 currTimestamp) acl() address +ActionInvalid(uint256 i, bytes4 action, bytes data) +addImplementation(address implementation, bytes4[] sigs) +addLiquidity(address recipient, uint256 subaccount, (uint8 kind, int32[] ticks, uint128[] amounts) params, bytes data) uint256 tokenAAmount, uint256 tokenBAmount, uint32[] binIds addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) uint256 amountA, uint256 amountB, uint256 liquidity addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) uint256 amountToken, uint256 amountETH, uint256 liquidity admin() address @@ -15,6 +19,7 @@ allowance(address user, address token, address spender) uint160 amount, uint48 e allPairsLength() uint256 approve(address spender, uint256 amount) bool success asset() address assetTokenAddress +balanceOf(address user, uint256 subaccount, uint32 binId) uint128 lpToken balanceOf(address) uint256 batchSwap(uint8 swapKind, (bytes32 poolId, uint256 assetInIndex, uint256 assetOutIndex, uint256 amount, bytes data)[] swaps, address[] assets, (address sender, bool fromInternalBalance, address recipient, bool toInternalBalance) funds, int256[] limits, uint256 deadline) int256[] beforeAddLiquidity(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, bytes hookData) bytes4 @@ -22,6 +27,8 @@ beforeDonate(address sender, (address currency0, address currency1, uint24 fee, beforeInitialize(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint160 sqrtPriceX96) bytes4 beforeRemoveLiquidity(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, bytes hookData) bytes4 beforeSwap(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96) params, bytes hookData) bytes4, int256, uint24 +binIdByTickKind(int32 tick, uint256 kind) uint32 +BoughtSellToken(address sellToken) burn(address from, uint256 id, uint256 amount) burn(address user, uint256 amount) burn(uint256) @@ -31,20 +38,30 @@ buyAsset(uint256 minAmount, address receiver) uint256, uint256 buyAssetWithSig(address originator, uint256 minAmount, address receiver, uint256 deadline, bytes signature) uint256, uint256 buyGem(address usr, uint256 gemAmt) uint256 daiInWad buyGemNoFee(address usr, uint256 gemAmt) uint256 daiInWad +CallbackNotSpent(uint256 callbackInt) cancelOrderRFQ(uint256 orderInfo) canPerform(bytes32 actionId, address account, address where) bool cbrt(uint256 x) uint256 +checkAuthorized(address spender, uint256 tokenId) address owner chug() uint256 wad claimMintReward() claimMintRewardAndShare(address other, uint256 pct) claimMintRewardAndStake(uint256 pct, uint256 term) +claimProtocolFeeForPool(address pool) +claimProtocolFeeForPool(address pool, bool isTokenA) clear(address currency, uint256 amount) coins(uint256 i) address collectProtocolFees(address recipient, address currency, uint256 amount) uint256 amountCollected +ConfusedDeputy() ContractLocked() convertToAssets(uint256 shares) uint256 assets convertToShares(uint256 assets) uint256 shares +create(uint64 fee, uint16 tickSpacing, uint32 lookback, address tokenA, address tokenB, int32 activeTick, uint8 kinds) address +create(uint64 feeAIn, uint64 feeBIn, uint16 tickSpacing, uint32 lookback, address tokenA, address tokenB, int32 activeTick, uint8 kinds) address createPair(address tokenA, address tokenB) address pair +createPermissioned(uint64 fee, uint16 tickSpacing, uint32 lookback, address tokenA, address tokenB, int32 activeTick, uint8 kinds, address accessor) address +createPermissioned(uint64 feeAIn, uint64 feeBIn, uint16 tickSpacing, uint32 lookback, address tokenA, address tokenB, int32 activeTick, uint8 kinds, address accessor) address +createPermissioned(uint64 feeAIn, uint64 feeBIn, uint16 tickSpacing, uint32 lookback, address tokenA, address tokenB, int32 activeTick, uint8 kinds, address accessor, bool permissionedLiquidity, bool permissionedSwap) address pool crossLmTick(int24 tick, bool zeroForOne) cumulativeSum() uint256 curveTricryptoSwapCallback(address payer, address receiver, address sellToken, uint256 sellAmount, uint256 buyAmount) @@ -52,6 +69,9 @@ cut() uint256 wad dec() uint256 decimals() uint8 decreaseAllowance(address spender, uint256 subtractedValue) bool success +DeltaNotNegative(address token) +DeltaNotPositive(address token) +deployParameters() uint64 feeAIn, uint64 feeBIn, uint32 lookback, int32 activeTick, uint64 tokenAScale, uint64 tokenBScale, address tokenA, address tokenB, uint16 tickSpacing, uint8 options, address accessor deposit() deposit(uint256 assets, address receiver) uint256 shares description() string @@ -95,6 +115,7 @@ exttload(bytes32 slot) bytes32 value exttload(bytes32[] slots) bytes32[] values factory() address fee() uint24 +fee(bool tokenAIn) uint256 feeGrowthGlobal0X128() uint256 feeGrowthGlobal1X128() uint256 fill() uint256 wad @@ -108,6 +129,8 @@ fillQuoteTokenToTokenWithPermit(address sellTokenAddress, address buyTokenAddres fillRfqOrderSelfFunded(address recipient, (address token, uint256 amount, uint256 nonce, uint256 deadline) permitted, address maker, bytes makerSig, address takerToken, uint256 maxTakerAmount) fillRfqOrderVIP(address recipient, (address token, uint256 amount, uint256 nonce, uint256 deadline) makerPermit, address maker, bytes makerSig, (address token, uint256 amount, uint256 nonce, uint256 deadline) takerPermit, bytes takerSig) flash(address recipient, uint256 amount0, uint256 amount1, bytes data) +flashLoan(address recipient, uint256 amountA, uint256 amountB, bytes data) uint128 lendingFeeA, uint128 lendingFeeB +ForwarderNotAllowed() FromAddressIsNotOwner() gemJoin() address geometric_mean(uint256[3] x) uint256 @@ -117,6 +140,7 @@ get_dy_underlying(int128 i, int128 j, uint256 amount) uint256 get_p(uint256[3] xp, uint256 D, uint256[2] A_gamma) uint256[2] get_registry() address get_y(uint256 ANN, uint256 gamma, uint256[3] x, uint256 D, uint256 i) uint256[2] +getAdmin() address getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) uint256 amountIn getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) uint256 amountOut getAmountsIn(uint256 amountOut, address[] path) uint256[] amounts @@ -125,10 +149,14 @@ getApp(bytes32 namespace, bytes32 appId) address getApproved(uint256 tokenId) address operator getAssetPriceInGho(uint256 assetAmount, bool roundUp) uint256 getAuthorizer() address +getBin(uint32 binId) (uint128 mergeBinBalance, uint128 tickBalance, uint128 totalSupply, uint8 kind, int32 tick, uint32 mergeId) bin getBuyFee(uint256 grossAmount) uint256 +getCurrentTwa() int256 +getDummyImplementation() address getGhoPriceInAsset(uint256 ghoAmount, bool roundUp) uint256 getGrossAmountFromTotalBought(uint256 totalAmount) uint256 getGrossAmountFromTotalSold(uint256 totalAmount) uint256 +getImplementationSigs(address impl) bytes4[] getInternalBalance(address user, address[] tokens) uint256[] getPair(address tokenA, address tokenB) address pair getReserves() uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast @@ -137,6 +165,9 @@ getRoleMember(bytes32 role, uint256 index) address getRoleMemberCount(bytes32 role) uint256 getRoundData(uint80 roundId) uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound getSellFee(uint256 grossAmount) uint256 +getSigsImplementation(bytes4 sig) address +getState() (uint128 reserveA, uint128 reserveB, int64 lastTwaD8, int64 lastLogPriceD8, uint40 lastTimestamp, int32 activeTick, bool isLocked, uint32 binCounter, uint8 protocolFeeRatioD3) +getTick(int32 tick) (uint128 reserveA, uint128 reserveB, uint128 totalSupply, uint32[4] binIdsByTick) tickState grantRole(bytes32 role, address account) gush() uint256 wad hasApprovedRelayer(address user, address relayer) bool @@ -148,26 +179,44 @@ initialize((address currency0, address currency1, uint24 fee, int24 tickSpacing, initialize(address token0, address token1) InsufficientETH() InsufficientToken() +InvalidAmount(uint256 maxAmount) InvalidBips() InvalidCommandType(uint256 commandType) +InvalidCurve(uint256 x, uint256 y) +InvalidOffset() InvalidOwnerERC1155() InvalidOwnerERC721() InvalidPath() InvalidReserves() +InvalidSender() +InvalidSignatureLen() +InvalidTarget() isApprovedForAll(address owner, address operator) bool +isFactoryPool(address pool) bool isSolver(address) bool isValidSignature(bytes32 hash, bytes data) bytes4 magic +kinds() uint8 kinds kLast() uint256 latestRoundData() uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound +lendingFeeRateD18() uint256 +LengthMismatch() liquidity() uint128 live() uint256 lmPool() address +lookback() uint256 +lookup(address _tokenA, address _tokenB, uint256 startIndex, uint256 endIndex) address[] pools +lookup(uint256 feeAIn, uint256 feeBIn, uint256 tickSpacing, uint256 lookback, address tokenA, address tokenB, uint8 kinds) address +lookup(uint256 startIndex, uint256 endIndex) address[] pools +lookupPermissioned(address _tokenA, address _tokenB, address accessor, uint256 startIndex, uint256 endIndex) address[] pools +lookupPermissioned(uint256 feeAIn, uint256 feeBIn, uint256 tickSpacing, uint256 lookback, address tokenA, address tokenB, uint8 options, address accessor) address +lookupPermissioned(uint256 startIndex, uint256 endIndex) address[] pools maverickV2SwapCallback(address tokenIn, uint256 amountIn, uint256 amountOut, bytes data) max(uint256, uint256) uint256 maxDeposit(address receiver) uint256 maxAssets maxMint(address receiver) uint256 maxShares maxRedeem(address owner) uint256 maxShares maxWithdraw(address owner) uint256 maxAssets +migrateBinUpStack(uint32 binId, uint32 maxRecursion) min(uint256, uint256) uint256 MINIMUM_LIQUIDITY() uint256 mint() @@ -177,8 +226,10 @@ mint(uint256 shares, address receiver) uint256 assets mint(uint256) mint_relative(address to, uint256 frac) uint256 modifyLiquidity((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, bytes hookData) int256 callerDelta, int256 feesAccrued +multicall(bytes[] data) bytes[] results name() string newton_D(uint256 ANN, uint256 gamma, uint256[3] x_unsorted, uint256 K0_prev) uint256 +nextTokenId() uint256 nextTokenId_ NoSlice() onERC721Received(address operator, address from, uint256 tokenId, bytes data) bytes4 onSwap((uint8 kind, address tokenIn, address tokenOut, uint256 amount, bytes32 poolId, uint256 lastChangeBlock, address from, address to, bytes userData) swapRequest, uint256[] balances, uint256 indexIn, uint256 indexOut) uint256 amount @@ -187,19 +238,57 @@ ownerOf(uint256 tokenId) address pancakeV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes data) Panic(uint256) paused() bool +PayerSpent() +PermissionDenied() +permissionedLiquidity() bool permissionedLiquidity +permissionedPool() bool permissionedPool +permissionedSwap() bool permissionedSwap permit(address owner, ((address token, uint160 amount, uint48 expiration, uint48 nonce)[] details, address spender, uint256 sigDeadline) permitBatch, bytes signature) permit(address owner, address spender, uint256 amount, uint256 deadline, uint8 v, bytes32 r, bytes32 s) +PoolBinIdsAmountsLengthMismatch(uint256 binIdsLength, uint256 amountsLength) +poolByTokenCount(address _tokenA, address _tokenB, address accessor) uint256 _poolCount +poolCount() uint256 _poolCount +PoolCurrentTickBeyondSwapLimit(int32 startingTick) +PoolFunctionNotImplemented() +PoolInsufficientBalance(uint256 deltaLpAmount, uint256 accountBalance) +PoolInvalidFee() +PoolKindNotSupported(uint256 kinds, uint256 kind) +PoolLocked() +PoolMigrateBinFirst() +PoolMinimumLiquidityNotMet() +poolPermissionedCount() uint256 _poolCount +PoolReservesExceedMaximum(uint256 amount) +PoolSenderNotAccessor(address sender, address accessor) +PoolSenderNotFactory(address sender, address accessor) +PoolTickMaxExceeded(uint256 tick) +PoolTicksAmountsLengthMismatch(uint256 ticksLength, uint256 amountsLength) +PoolTicksNotSorted(uint256 index, int256 previousTick, int256 tick) +PoolTokenNotSolvent(uint256 internalReserve, uint256 tokenBalance, address token) +PoolValueExceedsBits(uint256 amount, uint256 bits) +PoolZeroLiquidityAdded() previewDeposit(uint256 assets) uint256 shares previewMint(uint256 shares) uint256 assets previewRedeem(uint256 shares) uint256 assets previewWithdraw(uint256 assets) uint256 shares price0CumulativeLast() uint256 price1CumulativeLast() uint256 +protocolFeeA() uint128 +protocolFeeB() uint128 protocolFeeController() address +protocolFeeRatioD3() uint8 +protocolFeeReceiver() address protocolFeesAccrued(address currency) uint256 amount +protocolLendingFeeRateD18() uint256 quote(uint256 amountA, uint256 reserveA, uint256 reserveB) uint256 amountB +readFromStorage(bytes32 slot) uint256 result redeem(uint256 shares, address receiver, address owner) uint256 assets reduction_coefficient(uint256[3] x, uint256 fee_gamma) uint256 +ReentrantCallback(uint256 callbackInt) +ReentrantMetatransaction(bytes32 oldWitness) +ReentrantPayer(address oldPayer) +refundETH() +removeImplementation(address implementation) +removeLiquidity(address recipient, uint256 subaccount, (uint32[] binIds, uint128[] amounts) params) uint256 tokenAOut, uint256 tokenBOut removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) uint256 amountA, uint256 amountB removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) uint256 amountToken, uint256 amountETH removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) uint256 amountETH @@ -210,6 +299,10 @@ renounceOwnership() renounceRole(bytes32 role, address account) rescueTokens(address token, address to, uint256 amount) revokeRole(bytes32 role, address account) +RouterNotFactoryPool() +RouterTooLittleReceived(uint256 amountOutMinimum, uint256 amountOut) +RouterTooMuchRequested(uint256 amountInMaximum, uint256 amountIn) +RouterZeroSwap() rush() uint256 wad safeTransferFrom(address from, address to, uint256 tokenId) safeTransferFrom(address from, address to, uint256 tokenId, bytes data) @@ -218,10 +311,14 @@ sellAsset(uint256 maxAmount, address receiver) uint256, uint256 sellAssetWithSig(address originator, uint256 maxAmount, address receiver, uint256 deadline, bytes signature) uint256, uint256 sellBase(address to) uint256 receiveQuoteAmount sellGem(address usr, uint256 gemAmt) uint256 daiOutWad +sellGemNoFee(address usr, uint256 gemAmt) uint256 daiOutWad sellQuote(address to) uint256 receiveBaseAmount +setAdmin(address newAdmin) setApp(bytes32 namespace, bytes32 appId, address app) setApprovalForAll(address operator, bool approved) setAuthorizer(address newAuthorizer) +setDummyImplementation(address newDummyImplementation) +setFee(uint256 newFeeAIn, uint256 newFeeBIn) setProtocolFee((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint24 newProtocolFee) setProtocolFeeController(address controller) setRelayerApproval(address sender, address relayer, bool approved) @@ -244,6 +341,7 @@ settleSingle((uint256 expiry, address takerAddress, address makerAddress, uint25 settleSingleAndSignPermit((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256 makerAmount, uint256 makerNonce) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint256 deadline) takerPermitSignature) settleSingleAndSignPermit2((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256 makerAmount, uint256 makerNonce) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint48 deadline, uint48 nonce) takerPermit2Signature) settleWithPermitsSignatures((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, (bytes[] permitSignatures, bytes signatureBytesPermit2, uint48[] noncesPermit2, uint48 deadline) takerPermitsInfo, (bool result, address to, uint256 value, bytes data)[] interactions, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (address balanceRecipient, uint16 curFillPercent) solverData) +SignatureExpired(uint256 deadline) skim(address to) SliceOutOfBounds() SliceOverflow() @@ -251,6 +349,7 @@ slot0() (uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 obser stake(uint256 amount, uint256 term) supportsInterface(bytes4) bool swap((bytes32 poolId, uint8 swapKind, address assetIn, address assetOut, uint256 amount, bytes data) singleSwap, (address sender, bool fromInternalBalance, address recipient, bool toInternalBalance) funds, uint256 limit, uint256 deadline) uint256 +swap(address recipient, (uint256 amount, bool tokenAIn, bool exactOutput, int32 tickLimit) params, bytes data) uint256 amountIn, uint256 amountOut swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96) int256 amount0, int256 amount1 swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, bytes data) int256 amount0, int256 amount1 swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, bytes data, uint256 trackingCode) int256 amount0, int256 amount1 @@ -274,6 +373,8 @@ swapSingleFromContract((uint256 expiry, address takerAddress, address makerAddre swapTargets(address) bool swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] path, address to, uint256 deadline) uint256[] amounts swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] path, address to, uint256 deadline) uint256[] amounts +sweepToken(address token, uint256 amountMinimum, address recipient) +sweepTokenAmount(address token, uint256 amount, address recipient) symbol() string sync() sync(address currency) @@ -285,8 +386,14 @@ token() address token0() address token1() address tokenA() address +tokenAScale() uint256 tokenB() address +tokenBScale() uint256 +TokenHashCollision(address token0, address token1) +tokenIdsOfOwner(address owner) uint256[] tokenIds +tokenOfOwnerByIndexExists(address owner, uint256 index) bool tokenURI(uint256 tokenId) string +TooMuchSlippage(address token, uint256 expected, uint256 actual) totalAssets() uint256 totalManagedAssets totalShares() uint256 totalSupply() uint256 @@ -306,10 +413,15 @@ trim() uint256 wad UnableToClaim() uniswapV3Swap(uint256 amount, uint256 minReturn, uint256[] pools) uint256 returnAmount uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes data) +UnknownForkId(uint8 forkId) unlock(bytes data) bytes UnsafeCast() +unwrapAndSweep(address tokenA, address tokenB, uint256 tokenAAmountMin, uint256 tokenBAmountMin) +unwrapWETH9(uint256 amountMinimum, address recipient) updatedAt() uint256 updateDynamicLPFee((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint24 newDynamicLPFee) +updateProtocolFeeRatioForPool(address pool) +updateProtocolLendingFeeRateForPool(address pool) updateSwapTargets(address target, bool add) V2InvalidPath() V2TooLittleReceived() @@ -322,8 +434,14 @@ V3TooMuchRequested() version() uint256 wad_exp(int256 power) uint256 WETH() address +weth() address withdraw(uint256 assets, address receiver, address owner) uint256 shares withdraw(uint256) withdrawEth(address to, uint256 amount) withdrawToken(address token, address to, uint256 amount) +WitnessNotSpent(bytes32 oldWitness) wrapAll() +ZeroAddress() +ZeroBuyAmount(address buyToken) +ZeroSellAmount(address token) +ZeroToken() From 97254326fc7ed5900520ced475248669ce73ec76 Mon Sep 17 00:00:00 2001 From: lmittmann Date: Wed, 2 Apr 2025 11:27:00 +0200 Subject: [PATCH 09/11] added more curve funcs --- internal/fourbyte/funcs.go | 37 +++++++++++++++++++++++++++++++++++ internal/fourbyte/funcs.txt | 39 ++++++++++++++++++++++++++++++++++++- 2 files changed, 75 insertions(+), 1 deletion(-) diff --git a/internal/fourbyte/funcs.go b/internal/fourbyte/funcs.go index c80f64ea..76bb544c 100644 --- a/internal/fourbyte/funcs.go +++ b/internal/fourbyte/funcs.go @@ -5,6 +5,7 @@ import "github.com/lmittmann/w3" var functions = map[[4]byte]*w3.Func{ {0x01, 0x57, 0xaa, 0x77}: w3.MustNewFunc("updateProtocolLendingFeeRateForPool(address pool)", ""), + {0x01, 0x5c, 0x28, 0x38}: w3.MustNewFunc("set_new_fee(uint256 new_fee, uint256 new_offpeg_fee_multiplier)", ""), {0x01, 0x66, 0x4f, 0x66}: w3.MustNewFunc("gemJoin()", "address"), {0x01, 0xda, 0x15, 0x72}: w3.MustNewFunc("InvalidOffset()", ""), {0x01, 0xe1, 0xd1, 0x14}: w3.MustNewFunc("totalAssets()", "uint256 totalManagedAssets"), @@ -21,6 +22,7 @@ var functions = map[[4]byte]*w3.Func{ {0x06, 0xfd, 0xde, 0x03}: w3.MustNewFunc("name()", "string"), {0x07, 0x21, 0x1e, 0xf7}: w3.MustNewFunc("get_dy_underlying(int128 i, int128 j, uint256 amount)", "uint256"), {0x07, 0xa2, 0xd1, 0x3a}: w3.MustNewFunc("convertToAssets(uint256 shares)", "uint256 assets"), + {0x08, 0x15, 0x79, 0xa5}: w3.MustNewFunc("remove_liquidity_one_coin(uint256 burn_amount, int128 i, uint256 min_received, address receiver)", "uint256"), {0x08, 0x18, 0x12, 0xfc}: w3.MustNewFunc("getApproved(uint256 tokenId)", "address operator"), {0x08, 0xc3, 0x79, 0xa0}: w3.MustNewFunc("Error(string)", ""), {0x09, 0x02, 0xf1, 0xac}: w3.MustNewFunc("getReserves()", "uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast"), @@ -41,7 +43,9 @@ var functions = map[[4]byte]*w3.Func{ {0x12, 0x49, 0xc5, 0x8b}: w3.MustNewFunc("mint()", ""), {0x12, 0x8a, 0xcb, 0x08}: w3.MustNewFunc("swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, bytes data)", "int256 amount0, int256 amount1"), {0x13, 0xd7, 0x9a, 0x0b}: w3.MustNewFunc("settle(address[] tokens, uint256[] clearingPrices, (uint256 sellTokenIndex, uint256 buyTokenIndex, address receiver, uint256 sellAmount, uint256 buyAmount, uint32 validTo, bytes32 appData, uint256 feeAmount, uint256 flags, uint256 executedAmount, bytes signature)[] trades, (address target, uint256 value, bytes callData)[][3] interactions)", ""), + {0x14, 0x05, 0x22, 0x88}: w3.MustNewFunc("future_A_time()", "uint256"), {0x14, 0xe7, 0xa7, 0xab}: w3.MustNewFunc("settleAggregate((uint256 expiry, address takerAddress, address[] makerAddresses, uint256[] makerNonces, address[][] takerTokens, address[][] makerTokens, uint256[][] takerAmounts, uint256[][] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags)[] makersSignatures, uint256 filledTakerAmount, (bool useOldAmount, uint256[][] makerAmounts, uint256[] makerNonces) takerQuoteInfo, bytes takerSignature)", ""), + {0x14, 0xf0, 0x59, 0x79}: w3.MustNewFunc("get_balances()", "uint256[]"), {0x15, 0x0b, 0x7a, 0x02}: w3.MustNewFunc("onERC721Received(address operator, address from, uint256 tokenId, bytes data)", "bytes4"), {0x15, 0x6e, 0x29, 0xf6}: w3.MustNewFunc("mint(address to, uint256 id, uint256 amount)", ""), {0x15, 0xda, 0xcb, 0xea}: w3.MustNewFunc("transferFrom(address token, address owner, address recipient, uint256 amount)", "bool"), @@ -55,12 +59,15 @@ var functions = map[[4]byte]*w3.Func{ {0x1a, 0x49, 0x90, 0x26}: w3.MustNewFunc("settleSingle((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256 makerAmount, uint256 makerNonce) takerQuoteInfo, bytes takerSignature)", ""), {0x1a, 0x68, 0x65, 0x02}: w3.MustNewFunc("liquidity()", "uint128"), {0x1b, 0x9a, 0x91, 0xa4}: w3.MustNewFunc("withdrawEth(address to, uint256 amount)", ""), + {0x1b, 0xe9, 0x13, 0xa5}: w3.MustNewFunc("ma_exp_time()", "uint256"), {0x1c, 0x50, 0x0e, 0x5c}: w3.MustNewFunc("ForwarderNotAllowed()", ""), {0x1c, 0x56, 0x03, 0x05}: w3.MustNewFunc("claimMintRewardAndShare(address other, uint256 pct)", ""), + {0x1d, 0xdc, 0x3b, 0x01}: w3.MustNewFunc("ma_last_time()", "uint256"), {0x1d, 0xe2, 0x83, 0xa6}: w3.MustNewFunc("protocolFeeRatioD3()", "uint8"), {0x1e, 0x09, 0x21, 0x04}: w3.MustNewFunc("PermissionDenied()", ""), {0x1e, 0x2e, 0xae, 0xaf}: w3.MustNewFunc("extsload(bytes32 slot)", "bytes32 value"), {0x1f, 0x00, 0xca, 0x74}: w3.MustNewFunc("getAmountsIn(uint256 amountOut, address[] path)", "uint256[] amounts"), + {0x20, 0x81, 0x06, 0x6c}: w3.MustNewFunc("initial_A_time()", "uint256"), {0x20, 0xdb, 0x82, 0x67}: w3.MustNewFunc("InvalidPath()", ""), {0x21, 0x27, 0x2d, 0x4c}: w3.MustNewFunc("tokenBScale()", "uint256"), {0x21, 0x4a, 0x6f, 0xe2}: w3.MustNewFunc("accumulateReward(uint32 currTimestamp)", ""), @@ -76,6 +83,8 @@ var functions = map[[4]byte]*w3.Func{ {0x24, 0x8a, 0x9c, 0xa3}: w3.MustNewFunc("getRoleAdmin(bytes32 role)", "bytes32"), {0x25, 0x99, 0x82, 0xe5}: w3.MustNewFunc("beforeAddLiquidity(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, bytes hookData)", "bytes4"), {0x28, 0xb2, 0xa7, 0x96}: w3.MustNewFunc("settleInternalWithPermitsSignatures((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, (bytes[] permitSignatures, bytes signatureBytesPermit2, uint48[] noncesPermit2, uint48 deadline) takerPermitsInfo, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (uint256[] increasedBuyAmounts, uint16 curFillPercent) makerData)", ""), + {0x29, 0x35, 0x77, 0x50}: w3.MustNewFunc("N_COINS()", "uint256"), + {0x29, 0x69, 0xe0, 0x4a}: w3.MustNewFunc("remove_liquidity(uint256 burn_amount, uint256[] min_amounts, address receiver, bool claim_admin_fees)", "uint256[]"), {0x2a, 0x2d, 0x80, 0xd1}: w3.MustNewFunc("permit(address owner, ((address token, uint160 amount, uint48 expiration, uint48 nonce)[] details, address spender, uint256 sigDeadline) permitBatch, bytes signature)", ""), {0x2c, 0x40, 0x29, 0xe9}: w3.MustNewFunc("ExecutionFailed(uint256 commandIndex, bytes message)", ""), {0x2c, 0x50, 0xf4, 0xbe}: w3.MustNewFunc("PoolValueExceedsBits(uint256 amount, uint256 bits)", ""), @@ -84,6 +93,7 @@ var functions = map[[4]byte]*w3.Func{ {0x2e, 0x13, 0x67, 0x45}: w3.MustNewFunc("PoolLocked()", ""), {0x2e, 0x1a, 0x7d, 0x4d}: w3.MustNewFunc("withdraw(uint256)", ""), {0x2f, 0x2f, 0xf1, 0x5d}: w3.MustNewFunc("grantRole(bytes32 role, address account)", ""), + {0x30, 0xc5, 0x40, 0x85}: w3.MustNewFunc("withdraw_admin_fees()", ""), {0x31, 0x3c, 0xe5, 0x67}: w3.MustNewFunc("decimals()", "uint8"), {0x31, 0x6c, 0xf0, 0xeb}: w3.MustNewFunc("V3InvalidSwap()", ""), {0x31, 0xad, 0x53, 0xfa}: w3.MustNewFunc("protocolLendingFeeRateD18()", "uint256"), @@ -105,6 +115,7 @@ var functions = map[[4]byte]*w3.Func{ {0x38, 0xec, 0x02, 0x11}: w3.MustNewFunc("settleSingleAndSignPermit2((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256 makerAmount, uint256 makerNonce) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint48 deadline, uint48 nonce) takerPermit2Signature)", ""), {0x38, 0xed, 0x17, 0x39}: w3.MustNewFunc("swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline)", "uint256[] amounts"), {0x38, 0xef, 0x02, 0x53}: w3.MustNewFunc("permissionedSwap()", "bool permissionedSwap"), + {0x39, 0x31, 0xab, 0x52}: w3.MustNewFunc("last_price(uint256 i)", "uint256"), {0x39, 0x47, 0x47, 0xc5}: w3.MustNewFunc("exchange(uint256 i, uint256 j, uint256 dx, uint256 min_dy, bool use_eth)", ""), {0x39, 0x50, 0x93, 0x51}: w3.MustNewFunc("increaseAllowance(address spender, uint256 addedValue)", "bool success"), {0x39, 0xa5, 0x1b, 0xe5}: w3.MustNewFunc("protocolFeeReceiver()", "address"), @@ -113,8 +124,10 @@ var functions = map[[4]byte]*w3.Func{ {0x3a, 0x98, 0xef, 0x39}: w3.MustNewFunc("totalShares()", "uint256"), {0x3a, 0xb7, 0x2c, 0x10}: w3.MustNewFunc("tokenAScale()", "uint256"), {0x3b, 0x99, 0xb5, 0x3d}: w3.MustNewFunc("SliceOutOfBounds()", ""), + {0x3c, 0x15, 0x7e, 0x64}: w3.MustNewFunc("ramp_A(uint256 future_A, uint256 future_time)", ""), {0x3c, 0x2b, 0x9a, 0x7d}: w3.MustNewFunc("fillQuoteEthToToken(address buyTokenAddress, address target, bytes swapCallData, uint256 feeAmount)", ""), {0x3c, 0x74, 0xee, 0xd6}: w3.MustNewFunc("ActionInvalid(uint256 i, bytes4 action, bytes data)", ""), + {0x3d, 0xb0, 0x6d, 0xd8}: w3.MustNewFunc("calc_token_amount(uint256[] amounts, bool is_deposit)", "uint256"), {0x3d, 0xd4, 0x5a, 0xdb}: w3.MustNewFunc("settleFor(address recipient)", "uint256 paid"), {0x3d, 0xf0, 0x21, 0x24}: w3.MustNewFunc("exchange(int128 i, int128 j, uint256 dx, uint256 min_dy)", ""), {0x3e, 0xec, 0xe7, 0xdb}: w3.MustNewFunc("swap(address recipient, (uint256 amount, bool tokenAIn, bool exactOutput, int32 tickLimit) params, bytes data)", "uint256 amountIn, uint256 amountOut"), @@ -140,6 +153,7 @@ var functions = map[[4]byte]*w3.Func{ {0x48, 0x5c, 0xc9, 0x55}: w3.MustNewFunc("initialize(address token0, address token1)", ""), {0x48, 0xc8, 0x94, 0x91}: w3.MustNewFunc("unlock(bytes data)", "bytes"), {0x48, 0xfd, 0x65, 0xfe}: w3.MustNewFunc("tokenOfOwnerByIndexExists(address owner, uint256 index)", "bool"), + {0x49, 0x03, 0xb0, 0xd1}: w3.MustNewFunc("balances(uint256)", "uint256"), {0x49, 0x0e, 0x6c, 0xbc}: w3.MustNewFunc("flash(address recipient, uint256 amount0, uint256 amount1, bytes data)", ""), {0x49, 0x3f, 0x4f, 0x74}: w3.MustNewFunc("get_address(uint256 idx)", "address"), {0x49, 0x40, 0x4b, 0x7c}: w3.MustNewFunc("unwrapWETH9(uint256 amountMinimum, address recipient)", ""), @@ -147,6 +161,7 @@ var functions = map[[4]byte]*w3.Func{ {0x4a, 0x24, 0x8d, 0x2a}: w3.MustNewFunc("_BASE_TOKEN_()", "address"), {0x4a, 0x25, 0xd9, 0x4a}: w3.MustNewFunc("swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] path, address to, uint256 deadline)", "uint256[] amounts"), {0x4a, 0x2a, 0xb3, 0xbe}: w3.MustNewFunc("get_y(uint256 ANN, uint256 gamma, uint256[3] x, uint256 D, uint256 i)", "uint256[2]"), + {0x4a, 0x6e, 0x32, 0xc6}: w3.MustNewFunc("remove_liquidity_imbalance(uint256[] amounts, uint256 max_burn_amount, address receiver)", "uint256"), {0x4c, 0x08, 0x5b, 0xf1}: w3.MustNewFunc("DeltaNotPositive(address token)", ""), {0x4c, 0x84, 0xc1, 0xc8}: w3.MustNewFunc("wrapAll()", ""), {0x4c, 0xc4, 0x42, 0x56}: w3.MustNewFunc("claimProtocolFeeForPool(address pool, bool isTokenA)", ""), @@ -159,8 +174,10 @@ var functions = map[[4]byte]*w3.Func{ {0x52, 0xbb, 0xbe, 0x29}: w3.MustNewFunc("swap((bytes32 poolId, uint8 swapKind, address assetIn, address assetOut, uint256 amount, bytes data) singleSwap, (address sender, bool fromInternalBalance, address recipient, bool toInternalBalance) funds, uint256 limit, uint256 deadline)", "uint256"), {0x52, 0xc7, 0xf8, 0xdc}: w3.MustNewFunc("claimMintReward()", ""), {0x52, 0xf7, 0xc9, 0x88}: w3.MustNewFunc("setFee(uint256 newFeeAIn, uint256 newFeeBIn)", ""), + {0x54, 0x09, 0x49, 0x1a}: w3.MustNewFunc("initial_A()", "uint256"), {0x54, 0x0d, 0x49, 0x18}: w3.MustNewFunc("lmPool()", "address"), {0x54, 0xfd, 0x4d, 0x50}: w3.MustNewFunc("version()", "uint256"), + {0x55, 0x1a, 0x65, 0x88}: w3.MustNewFunc("stop_ramp_A()", ""), {0x55, 0xe4, 0xb7, 0xbe}: w3.MustNewFunc("fillQuoteTokenToToken(address sellTokenAddress, address buyTokenAddress, address target, bytes swapCallData, uint256 sellAmount, uint256 feeAmount)", ""), {0x56, 0x85, 0x76, 0x42}: w3.MustNewFunc("accessor()", "address"), {0x57, 0x4f, 0x2b, 0xa3}: w3.MustNewFunc("allPairsLength()", "uint256"), @@ -192,12 +209,15 @@ var functions = map[[4]byte]*w3.Func{ {0x64, 0x28, 0x3d, 0x7b}: w3.MustNewFunc("ERC721IncorrectOwner(address sender, uint256 tokenId, address owner)", ""), {0x64, 0x67, 0x7e, 0x32}: w3.MustNewFunc("claimProtocolFeeForPool(address pool)", ""), {0x64, 0xa0, 0xae, 0x92}: w3.MustNewFunc("ERC721InvalidReceiver(address receiver)", ""), + {0x65, 0xbb, 0xea, 0x6b}: w3.MustNewFunc("set_ma_exp_time(uint256 ma_exp_time, uint256 D_ma_time)", ""), {0x66, 0xa6, 0x5e, 0x41}: w3.MustNewFunc("settleMultiAndSignPermit2((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address[] takerTokens, address[] makerTokens, uint256[] takerAmounts, uint256[] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256[] makerAmounts, uint256 makerNonce) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint48 deadline, uint48[] nonces) infoPermit2)", ""), {0x67, 0x0c, 0xa1, 0x81}: w3.MustNewFunc("unwrapAndSweep(address tokenA, address tokenB, uint256 tokenAAmountMin, uint256 tokenBAmountMin)", ""), {0x67, 0x1c, 0x21, 0x15}: w3.MustNewFunc("fillRfqOrderVIP(address recipient, (address token, uint256 amount, uint256 nonce, uint256 deadline) makerPermit, address maker, bytes makerSig, (address token, uint256 amount, uint256 nonce, uint256 deadline) takerPermit, bytes takerSig)", ""), {0x67, 0x5c, 0xae, 0x38}: w3.MustNewFunc("InsufficientToken()", ""), {0x67, 0x9f, 0x05, 0x79}: w3.MustNewFunc("flashLoan(address recipient, uint256 amountA, uint256 amountB, bytes data)", "uint128 lendingFeeA, uint128 lendingFeeB"), {0x67, 0xca, 0x7c, 0x91}: w3.MustNewFunc("maverickV2SwapCallback(address tokenIn, uint256 amountIn, uint256 amountOut, bytes data)", ""), + {0x67, 0xdf, 0x02, 0xca}: w3.MustNewFunc("get_dx(int128 i, int128 j, uint256 dy)", "uint256"), + {0x68, 0x72, 0x76, 0x53}: w3.MustNewFunc("price_oracle(uint256 i)", "uint256"), {0x69, 0x62, 0xf8, 0x45}: w3.MustNewFunc("mint_relative(address to, uint256 frac)", "uint256"), {0x6a, 0x12, 0xf1, 0x04}: w3.MustNewFunc("InsufficientETH()", ""), {0x6c, 0x2b, 0xbe, 0x7e}: w3.MustNewFunc("afterRemoveLiquidity(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, int256 delta, int256 feesAccrued, bytes hookData)", "bytes4, int256"), @@ -221,6 +241,8 @@ var functions = map[[4]byte]*w3.Func{ {0x75, 0x4b, 0x76, 0xb3}: w3.MustNewFunc("get_p(uint256[3] xp, uint256 D, uint256[2] A_gamma)", "uint256[2]"), {0x75, 0x79, 0x4a, 0x3c}: w3.MustNewFunc("nextTokenId()", "uint256 nextTokenId_"), {0x75, 0xd3, 0x9e, 0xcb}: w3.MustNewFunc("swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, uint256 amountLimit, uint256 deadline)", "int256 amount0, int256 amount1"), + {0x76, 0xa2, 0xf0, 0xf0}: w3.MustNewFunc("A_precise()", "uint256"), + {0x76, 0xa9, 0xcd, 0x3e}: w3.MustNewFunc("dynamic_fee(int128 i, int128 j)", "uint256"), {0x77, 0x14, 0x6e, 0x62}: w3.MustNewFunc("ToAddressOverflow()", ""), {0x78, 0x4c, 0xb7, 0xb8}: w3.MustNewFunc("BoughtSellToken(address sellToken)", ""), {0x79, 0x1a, 0xc9, 0x47}: w3.MustNewFunc("swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline)", ""), @@ -235,6 +257,7 @@ var functions = map[[4]byte]*w3.Func{ {0x7d, 0xbe, 0x7e, 0x89}: w3.MustNewFunc("InvalidOwnerERC721()", ""), {0x7e, 0x27, 0x32, 0x89}: w3.MustNewFunc("ERC721NonexistentToken(uint256 tokenId)", ""), {0x7e, 0x87, 0xce, 0x7d}: w3.MustNewFunc("setProtocolFee((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint24 newProtocolFee)", ""), + {0x7e, 0xce, 0xbe, 0x00}: w3.MustNewFunc("nonces(address)", "uint256"), {0x7f, 0xf3, 0x6a, 0xb5}: w3.MustNewFunc("swapExactETHForTokens(uint256 amountOutMin, address[] path, address to, uint256 deadline)", "uint256[] amounts"), {0x80, 0xf0, 0xb4, 0x4c}: w3.MustNewFunc("clear(address currency, uint256 amount)", ""), {0x81, 0x61, 0xb8, 0x74}: w3.MustNewFunc("collectProtocolFees(address recipient, address currency, uint256 amount)", "uint256 amountCollected"), @@ -261,10 +284,13 @@ var functions = map[[4]byte]*w3.Func{ {0x8d, 0x7e, 0xf9, 0xbb}: w3.MustNewFunc("buyGem(address usr, uint256 gemAmt)", "uint256 daiInWad"), {0x8d, 0xa5, 0xcb, 0x5b}: w3.MustNewFunc("owner()", "address"), {0x8e, 0x54, 0x30, 0xa7}: w3.MustNewFunc("migrateBinUpStack(uint32 binId, uint32 maxRecursion)", ""), + {0x8e, 0xdf, 0xdd, 0x5f}: w3.MustNewFunc("offpeg_fee_multiplier()", "uint256"), {0x90, 0x10, 0xd0, 0x7c}: w3.MustNewFunc("getRoleMember(bytes32 role, uint256 index)", "address"), {0x90, 0x26, 0xb8, 0xbc}: w3.MustNewFunc("protocolFeeB()", "uint128"), + {0x90, 0x7a, 0x01, 0x6b}: w3.MustNewFunc("D_oracle()", "uint256"), {0x90, 0x8b, 0xfe, 0x5e}: w3.MustNewFunc("getDummyImplementation()", "address"), {0x90, 0x93, 0xbf, 0x7b}: w3.MustNewFunc("settleAggregateAndSignPermit((uint256 expiry, address takerAddress, address[] makerAddresses, uint256[] makerNonces, address[][] takerTokens, address[][] makerTokens, uint256[][] takerAmounts, uint256[][] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags)[] makersSignatures, uint256 filledTakerAmount, (bool useOldAmount, uint256[][] makerAmounts, uint256[] makerNonces) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint256 deadline) takerPermitSignature)", ""), + {0x90, 0xd2, 0x08, 0x37}: w3.MustNewFunc("ema_price(uint256 i)", "uint256"), {0x91, 0xd1, 0x48, 0x54}: w3.MustNewFunc("hasRole(bytes32 role, address account)", "bool"), {0x92, 0x7d, 0xa1, 0x05}: w3.MustNewFunc("allowance(address user, address token, address spender)", "uint160 amount, uint48 expiration, uint48 nonce"), {0x93, 0x29, 0x34, 0x0d}: w3.MustNewFunc("binIdByTickKind(int32 tick, uint256 kind)", "uint32"), @@ -291,6 +317,7 @@ var functions = map[[4]byte]*w3.Func{ {0x9b, 0x65, 0x2d, 0xf6}: w3.MustNewFunc("chug()", "uint256 wad"), {0x9b, 0xe2, 0xa8, 0x84}: w3.MustNewFunc("canPerform(bytes32 actionId, address account, address where)", "bool"), {0x9b, 0xf6, 0x64, 0x5f}: w3.MustNewFunc("exttload(bytes32[] slots)", "bytes32[] values"), + {0x9c, 0x42, 0x58, 0xc4}: w3.MustNewFunc("D_ma_time()", "uint256"), {0x9d, 0xc2, 0x9f, 0xac}: w3.MustNewFunc("burn(address user, uint256 amount)", ""), {0x9d, 0xc6, 0xcc, 0xae}: w3.MustNewFunc("updateProtocolFeeRatioForPool(address pool)", ""), {0x9e, 0x59, 0xe5, 0x98}: w3.MustNewFunc("tokenIdsOfOwner(address owner)", "uint256[] tokenIds"), @@ -323,6 +350,7 @@ var functions = map[[4]byte]*w3.Func{ {0xae, 0x52, 0xad, 0x0c}: w3.MustNewFunc("V2InvalidPath()", ""), {0xae, 0x5b, 0x25, 0x40}: w3.MustNewFunc("setApp(bytes32 namespace, bytes32 appId, address app)", ""), {0xaf, 0x29, 0x79, 0xeb}: w3.MustNewFunc("removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline)", "uint256 amountETH"), + {0xaf, 0xb4, 0x30, 0x12}: w3.MustNewFunc("exchange_received(int128 i, int128 j, uint256 dx, uint256 min_dy, address receiver)", "uint256"), {0xb0, 0x34, 0x43, 0x04}: w3.MustNewFunc("swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, bytes data, uint256 trackingCode)", "int256 amount0, int256 amount1"), {0xb0, 0x48, 0x0b, 0xbd}: w3.MustNewFunc("fillQuoteTokenToTokenWithPermit(address sellTokenAddress, address buyTokenAddress, address target, bytes swapCallData, uint256 sellAmount, uint256 feeAmount, (uint256 value, uint256 nonce, uint256 deadline, bool isDaiStylePermit, uint8 v, bytes32 r, bytes32 s) permitData)", ""), {0xb3, 0x09, 0x38, 0x38}: w3.MustNewFunc("fillQuoteTokenToEthWithPermit(address sellTokenAddress, address target, bytes swapCallData, uint256 sellAmount, uint256 feePercentageBasisPoints, (uint256 value, uint256 nonce, uint256 deadline, bool isDaiStylePermit, uint8 v, bytes32 r, bytes32 s) permitData)", ""), @@ -330,6 +358,7 @@ var functions = map[[4]byte]*w3.Func{ {0xb3, 0xd7, 0xf6, 0xb9}: w3.MustNewFunc("previewMint(uint256 shares)", "uint256 assets"), {0xb4, 0x60, 0xaf, 0x94}: w3.MustNewFunc("withdraw(uint256 assets, address receiver, address owner)", "uint256 shares"), {0xb4, 0x7b, 0x2f, 0xb1}: w3.MustNewFunc("afterSwap(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96) params, int256 delta, bytes hookData)", "bytes4, int128"), + {0xb4, 0xb5, 0x77, 0xad}: w3.MustNewFunc("future_A()", "uint256"), {0xb4, 0xb9, 0xd1, 0xf1}: w3.MustNewFunc("lookup(uint256 startIndex, uint256 endIndex)", "address[] pools"), {0xb4, 0xc9, 0x91, 0xc6}: w3.MustNewFunc("poolByTokenCount(address _tokenA, address _tokenB, address accessor)", "uint256 _poolCount"), {0xb5, 0xc7, 0x36, 0xe4}: w3.MustNewFunc("readFromStorage(bytes32 slot)", "uint256 result"), @@ -342,9 +371,11 @@ var functions = map[[4]byte]*w3.Func{ {0xba, 0xa2, 0xab, 0xde}: w3.MustNewFunc("removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline)", "uint256 amountA, uint256 amountB"), {0xba, 0xba, 0x58, 0x55}: w3.MustNewFunc("fillOrderRFQTo((uint256 info, address makerAsset, address takerAsset, address maker, address allowedSender, uint256 makingAmount, uint256 takingAmount) order, bytes signature, uint256 makingAmount, uint256 takingAmount, address target)", ""), {0xba, 0xd1, 0xdc, 0x26}: w3.MustNewFunc("geometric_mean(uint256[3] x)", "uint256"), + {0xbb, 0x7b, 0x8b, 0x80}: w3.MustNewFunc("get_virtual_price()", "uint256"), {0xbc, 0x25, 0xcf, 0x77}: w3.MustNewFunc("skim(address to)", ""), {0xbd, 0x60, 0x15, 0xb4}: w3.MustNewFunc("sellBase(address to)", "uint256 receiveQuoteAmount"), {0xbe, 0x00, 0xbb, 0xd8}: w3.MustNewFunc("getApp(bytes32 namespace, bytes32 appId)", "address"), + {0xbf, 0xa0, 0xb1, 0x33}: w3.MustNewFunc("salt()", "bytes32"), {0xc0, 0x4b, 0x8d, 0x59}: w3.MustNewFunc("exactInput((bytes path, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum) params)", "uint256 amountOut"), {0xc1, 0x58, 0x3f, 0x2c}: w3.MustNewFunc("PoolReservesExceedMaximum(uint256 amount)", ""), {0xc3, 0x1b, 0x8d, 0x7a}: w3.MustNewFunc("swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96)", "int256 amount0, int256 amount1"), @@ -363,6 +394,7 @@ var functions = map[[4]byte]*w3.Func{ {0xca, 0xbc, 0x4f, 0x38}: w3.MustNewFunc("PoolTicksAmountsLengthMismatch(uint256 ticksLength, uint256 amountsLength)", ""), {0xcb, 0xf0, 0xbf, 0xac}: w3.MustNewFunc("rush()", "uint256 wad"), {0xcb, 0xf0, 0xdb, 0xf5}: w3.MustNewFunc("ZeroBuyAmount(address buyToken)", ""), + {0xcc, 0x2b, 0x27, 0xd7}: w3.MustNewFunc("calc_withdraw_one_coin(uint256 burn_amount, int128 i)", "uint256"), {0xcc, 0x94, 0xa6, 0x3a}: w3.MustNewFunc("NoSlice()", ""), {0xcd, 0x21, 0xdb, 0x4f}: w3.MustNewFunc("SignatureExpired(uint256 deadline)", ""), {0xce, 0x7d, 0x65, 0x03}: w3.MustNewFunc("exchange(uint256 i, uint256 j, uint256 dx, uint256 min_dy, bool use_eth, address receiver)", "uint256"), @@ -404,6 +436,7 @@ var functions = map[[4]byte]*w3.Func{ {0xe1, 0xb4, 0xaf, 0x69}: w3.MustNewFunc("afterDonate(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint256 amount0, uint256 amount1, bytes hookData)", "bytes4"), {0xe2, 0x55, 0x27, 0xc2}: w3.MustNewFunc("WitnessNotSpent(bytes32 oldWitness)", ""), {0xe2, 0x62, 0x79, 0x0d}: w3.MustNewFunc("lookup(address _tokenA, address _tokenB, uint256 startIndex, uint256 endIndex)", "address[] pools"), + {0xe2, 0xe7, 0xd2, 0x64}: w3.MustNewFunc("admin_balances(uint256)", "uint256"), {0xe4, 0x49, 0x02, 0x2e}: w3.MustNewFunc("uniswapV3Swap(uint256 amount, uint256 minReturn, uint256[] pools)", "uint256 returnAmount"), {0xe4, 0x50, 0xd3, 0x8c}: w3.MustNewFunc("ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed)", ""), {0xe5, 0x59, 0xab, 0xbf}: w3.MustNewFunc("create(uint64 fee, uint16 tickSpacing, uint32 lookback, address tokenA, address tokenB, int32 activeTick, uint8 kinds)", "address"), @@ -416,6 +449,7 @@ var functions = map[[4]byte]*w3.Func{ {0xe9, 0x85, 0xe9, 0xc5}: w3.MustNewFunc("isApprovedForAll(address owner, address operator)", "bool"), {0xeb, 0x8d, 0x21, 0x16}: w3.MustNewFunc("transferTokens((address from, address receiver, address[] tokens, uint256[] amounts, uint256[] nftIds, bytes tokenTransferTypes, uint16 fillPercent) transferData)", ""), {0xeb, 0xcb, 0xd2, 0x81}: w3.MustNewFunc("lookback()", "uint256"), + {0xec, 0x02, 0x38, 0x62}: w3.MustNewFunc("get_p(uint256 i)", "uint256"), {0xec, 0x44, 0x2f, 0x05}: w3.MustNewFunc("ERC20InvalidReceiver(address receiver)", ""), {0xec, 0x98, 0x37, 0x76}: w3.MustNewFunc("settleWithPermitsSignatures((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers) order, (uint8 type, bytes signatureBytes) signature, (bytes[] permitSignatures, bytes signatureBytesPermit2, uint48[] noncesPermit2, uint48 deadline) takerPermitsInfo, (bool result, address to, uint256 value, bytes data)[] interactions, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle) hooks, (address balanceRecipient, uint16 curFillPercent) solverData)", ""), {0xef, 0x7d, 0x27, 0xad}: w3.MustNewFunc("settleSingleAndSignPermit((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256 makerAmount, uint256 makerNonce) takerQuoteInfo, bytes takerSignature, (bytes signatureBytes, uint256 deadline) takerPermitSignature)", ""), @@ -430,6 +464,7 @@ var functions = map[[4]byte]*w3.Func{ {0xf3, 0x05, 0x83, 0x99}: w3.MustNewFunc("feeGrowthGlobal0X128()", "uint256"), {0xf3, 0x05, 0xd7, 0x19}: w3.MustNewFunc("addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline)", "uint256 amountToken, uint256 amountETH, uint256 liquidity"), {0xf4, 0x2c, 0x56, 0xc2}: w3.MustNewFunc("cbrt(uint256 x)", "uint256"), + {0xf4, 0x46, 0xc1, 0xd0}: w3.MustNewFunc("A()", "uint256"), {0xf4, 0x93, 0xca, 0x70}: w3.MustNewFunc("sellAssetWithSig(address originator, uint256 maxAmount, address receiver, uint256 deadline, bytes signature)", "uint256, uint256"), {0xf4, 0xb5, 0x24, 0x83}: w3.MustNewFunc("create(uint64 feeAIn, uint64 feeBIn, uint16 tickSpacing, uint32 lookback, address tokenA, address tokenB, int32 activeTick, uint8 kinds)", "address"), {0xf5, 0x25, 0xcb, 0x68}: w3.MustNewFunc("poolCount()", "uint256 _poolCount"), @@ -446,9 +481,11 @@ var functions = map[[4]byte]*w3.Func{ {0xfb, 0x77, 0x2a, 0x88}: w3.MustNewFunc("ZeroSellAmount(address token)", ""), {0xfb, 0x8f, 0x41, 0xb2}: w3.MustNewFunc("ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed)", ""), {0xfc, 0x0c, 0x54, 0x6a}: w3.MustNewFunc("token()", "address"), + {0xfd, 0x06, 0x84, 0xb1}: w3.MustNewFunc("stored_rates()", "uint256[]"), {0xfd, 0xef, 0x91, 0x06}: w3.MustNewFunc("hasPermission(address who, address where, bytes32 what, bytes how)", "bool"), {0xfe, 0xaf, 0x96, 0x8c}: w3.MustNewFunc("latestRoundData()", "uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound"), {0xfe, 0xc9, 0x0d, 0x72}: w3.MustNewFunc("hasApprovedRelayer(address user, address relayer)", "bool"), + {0xfe, 0xe3, 0xf7, 0xf9}: w3.MustNewFunc("admin_fee()", "uint256"), {0xff, 0x63, 0x3a, 0x38}: w3.MustNewFunc("LengthMismatch()", ""), {0xff, 0xf6, 0xca, 0xe9}: w3.MustNewFunc("sync()", ""), } diff --git a/internal/fourbyte/funcs.txt b/internal/fourbyte/funcs.txt index 338bfe64..e4c2aa30 100644 --- a/internal/fourbyte/funcs.txt +++ b/internal/fourbyte/funcs.txt @@ -1,5 +1,7 @@ _BASE_TOKEN_() address _QUOTE_TOKEN_() address +A() uint256 +A_precise() uint256 accessor() address accumulateReward(uint32 currTimestamp) acl() address @@ -9,6 +11,8 @@ addLiquidity(address recipient, uint256 subaccount, (uint8 kind, int32[] ticks, addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) uint256 amountA, uint256 amountB, uint256 liquidity addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) uint256 amountToken, uint256 amountETH, uint256 liquidity admin() address +admin_balances(uint256) uint256 +admin_fee() uint256 afterAddLiquidity(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, int256 delta, int256 feesAccrued, bytes hookData) bytes4, int256 afterDonate(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint256 amount0, uint256 amount1, bytes hookData) bytes4 afterInitialize(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint160 sqrtPriceX96, int24 tick) bytes4 @@ -21,6 +25,7 @@ approve(address spender, uint256 amount) bool success asset() address assetTokenAddress balanceOf(address user, uint256 subaccount, uint32 binId) uint128 lpToken balanceOf(address) uint256 +balances(uint256) uint256 batchSwap(uint8 swapKind, (bytes32 poolId, uint256 assetInIndex, uint256 assetOutIndex, uint256 amount, bytes data)[] swaps, address[] assets, (address sender, bool fromInternalBalance, address recipient, bool toInternalBalance) funds, int256[] limits, uint256 deadline) int256[] beforeAddLiquidity(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, bytes hookData) bytes4 beforeDonate(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint256 amount0, uint256 amount1, bytes hookData) bytes4 @@ -38,6 +43,8 @@ buyAsset(uint256 minAmount, address receiver) uint256, uint256 buyAssetWithSig(address originator, uint256 minAmount, address receiver, uint256 deadline, bytes signature) uint256, uint256 buyGem(address usr, uint256 gemAmt) uint256 daiInWad buyGemNoFee(address usr, uint256 gemAmt) uint256 daiInWad +calc_token_amount(uint256[] amounts, bool is_deposit) uint256 +calc_withdraw_one_coin(uint256 burn_amount, int128 i) uint256 CallbackNotSpent(uint256 callbackInt) cancelOrderRFQ(uint256 orderInfo) canPerform(bytes32 actionId, address account, address where) bool @@ -66,6 +73,8 @@ crossLmTick(int24 tick, bool zeroForOne) cumulativeSum() uint256 curveTricryptoSwapCallback(address payer, address receiver, address sellToken, uint256 sellAmount, uint256 buyAmount) cut() uint256 wad +D_ma_time() uint256 +D_oracle() uint256 dec() uint256 decimals() uint8 decreaseAllowance(address spender, uint256 subtractedValue) bool success @@ -77,6 +86,8 @@ deposit(uint256 assets, address receiver) uint256 shares description() string DOMAIN_SEPARATOR() bytes32 donate((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint256 amount0, uint256 amount1, bytes hookData) int256 delta +dynamic_fee(int128 i, int128 j) uint256 +ema_price(uint256 i) uint256 ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed) ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed) ERC20InvalidApprover(address approver) @@ -103,6 +114,7 @@ exchange(uint256 i, uint256 j, uint256 dx, uint256 min_dy) exchange(uint256 i, uint256 j, uint256 dx, uint256 min_dy, bool use_eth) exchange(uint256 i, uint256 j, uint256 dx, uint256 min_dy, bool use_eth, address receiver) uint256 exchange_extended(uint256 sellIndex, uint256 buyIndex, uint256 sellAmount, uint256 minBuyAmount, bool useEth, address payer, address receiver, bytes32 callbackSelector) uint256 buyAmount +exchange_received(int128 i, int128 j, uint256 dx, uint256 min_dy, address receiver) uint256 exchange_underlying(int128 i, int128 j, uint256 dx, uint256 min_dy) exec(address operator, address token, uint256 amount, address target, bytes data) bytes result execute(bytes commands, bytes[] inputs) @@ -132,13 +144,19 @@ flash(address recipient, uint256 amount0, uint256 amount1, bytes data) flashLoan(address recipient, uint256 amountA, uint256 amountB, bytes data) uint128 lendingFeeA, uint128 lendingFeeB ForwarderNotAllowed() FromAddressIsNotOwner() +future_A() uint256 +future_A_time() uint256 gemJoin() address geometric_mean(uint256[3] x) uint256 get_address(uint256 idx) address +get_balances() uint256[] +get_dx(int128 i, int128 j, uint256 dy) uint256 get_dy(int128 i, int128 j, uint256 amount) uint256 get_dy_underlying(int128 i, int128 j, uint256 amount) uint256 +get_p(uint256 i) uint256 get_p(uint256[3] xp, uint256 D, uint256[2] A_gamma) uint256[2] get_registry() address +get_virtual_price() uint256 get_y(uint256 ANN, uint256 gamma, uint256[3] x, uint256 D, uint256 i) uint256[2] getAdmin() address getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) uint256 amountIn @@ -175,6 +193,8 @@ hasPermission(address who, address where, bytes32 what, bytes how) bool hasRole(bytes32 role, address account) bool implementation() address increaseAllowance(address spender, uint256 addedValue) bool success +initial_A() uint256 +initial_A_time() uint256 initialize((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint160 sqrtPriceX96) int24 tick initialize(address token0, address token1) InsufficientETH() @@ -197,6 +217,7 @@ isSolver(address) bool isValidSignature(bytes32 hash, bytes data) bytes4 magic kinds() uint8 kinds kLast() uint256 +last_price(uint256 i) uint256 latestRoundData() uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound lendingFeeRateD18() uint256 LengthMismatch() @@ -210,6 +231,8 @@ lookup(uint256 startIndex, uint256 endIndex) address[] pools lookupPermissioned(address _tokenA, address _tokenB, address accessor, uint256 startIndex, uint256 endIndex) address[] pools lookupPermissioned(uint256 feeAIn, uint256 feeBIn, uint256 tickSpacing, uint256 lookback, address tokenA, address tokenB, uint8 options, address accessor) address lookupPermissioned(uint256 startIndex, uint256 endIndex) address[] pools +ma_exp_time() uint256 +ma_last_time() uint256 maverickV2SwapCallback(address tokenIn, uint256 amountIn, uint256 amountOut, bytes data) max(uint256, uint256) uint256 maxDeposit(address receiver) uint256 maxAssets @@ -227,10 +250,13 @@ mint(uint256) mint_relative(address to, uint256 frac) uint256 modifyLiquidity((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, bytes hookData) int256 callerDelta, int256 feesAccrued multicall(bytes[] data) bytes[] results +N_COINS() uint256 name() string newton_D(uint256 ANN, uint256 gamma, uint256[3] x_unsorted, uint256 K0_prev) uint256 nextTokenId() uint256 nextTokenId_ +nonces(address) uint256 NoSlice() +offpeg_fee_multiplier() uint256 onERC721Received(address operator, address from, uint256 tokenId, bytes data) bytes4 onSwap((uint8 kind, address tokenIn, address tokenOut, uint256 amount, bytes32 poolId, uint256 lastChangeBlock, address from, address to, bytes userData) swapRequest, uint256[] balances, uint256 indexIn, uint256 indexOut) uint256 amount owner() address @@ -272,6 +298,7 @@ previewRedeem(uint256 shares) uint256 assets previewWithdraw(uint256 assets) uint256 shares price0CumulativeLast() uint256 price1CumulativeLast() uint256 +price_oracle(uint256 i) uint256 protocolFeeA() uint128 protocolFeeB() uint128 protocolFeeController() address @@ -280,6 +307,7 @@ protocolFeeReceiver() address protocolFeesAccrued(address currency) uint256 amount protocolLendingFeeRateD18() uint256 quote(uint256 amountA, uint256 reserveA, uint256 reserveB) uint256 amountB +ramp_A(uint256 future_A, uint256 future_time) readFromStorage(bytes32 slot) uint256 result redeem(uint256 shares, address receiver, address owner) uint256 assets reduction_coefficient(uint256[3] x, uint256 fee_gamma) uint256 @@ -287,6 +315,9 @@ ReentrantCallback(uint256 callbackInt) ReentrantMetatransaction(bytes32 oldWitness) ReentrantPayer(address oldPayer) refundETH() +remove_liquidity(uint256 burn_amount, uint256[] min_amounts, address receiver, bool claim_admin_fees) uint256[] +remove_liquidity_imbalance(uint256[] amounts, uint256 max_burn_amount, address receiver) uint256 +remove_liquidity_one_coin(uint256 burn_amount, int128 i, uint256 min_received, address receiver) uint256 removeImplementation(address implementation) removeLiquidity(address recipient, uint256 subaccount, (uint32[] binIds, uint128[] amounts) params) uint256 tokenAOut, uint256 tokenBOut removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) uint256 amountA, uint256 amountB @@ -306,6 +337,7 @@ RouterZeroSwap() rush() uint256 wad safeTransferFrom(address from, address to, uint256 tokenId) safeTransferFrom(address from, address to, uint256 tokenId, bytes data) +salt() bytes32 seize() uint256 sellAsset(uint256 maxAmount, address receiver) uint256, uint256 sellAssetWithSig(address originator, uint256 maxAmount, address receiver, uint256 deadline, bytes signature) uint256, uint256 @@ -313,6 +345,8 @@ sellBase(address to) uint256 receiveQuoteAmount sellGem(address usr, uint256 gemAmt) uint256 daiOutWad sellGemNoFee(address usr, uint256 gemAmt) uint256 daiOutWad sellQuote(address to) uint256 receiveBaseAmount +set_ma_exp_time(uint256 ma_exp_time, uint256 D_ma_time) +set_new_fee(uint256 new_fee, uint256 new_offpeg_fee_multiplier) setAdmin(address newAdmin) setApp(bytes32 namespace, bytes32 appId, address app) setApprovalForAll(address operator, bool approved) @@ -347,6 +381,8 @@ SliceOutOfBounds() SliceOverflow() slot0() (uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint8 feeProtocol, bool unlocked) stake(uint256 amount, uint256 term) +stop_ramp_A() +stored_rates() uint256[] supportsInterface(bytes4) bool swap((bytes32 poolId, uint8 swapKind, address assetIn, address assetOut, uint256 amount, bytes data) singleSwap, (address sender, bool fromInternalBalance, address recipient, bool toInternalBalance) funds, uint256 limit, uint256 deadline) uint256 swap(address recipient, (uint256 amount, bool tokenAIn, bool exactOutput, int32 tickLimit) params, bytes data) uint256 amountIn, uint256 amountOut @@ -433,10 +469,11 @@ V3TooLittleReceived() V3TooMuchRequested() version() uint256 wad_exp(int256 power) uint256 -WETH() address weth() address +WETH() address withdraw(uint256 assets, address receiver, address owner) uint256 shares withdraw(uint256) +withdraw_admin_fees() withdrawEth(address to, uint256 amount) withdrawToken(address token, address to, uint256 amount) WitnessNotSpent(bytes32 oldWitness) From 42b5526d240a75d684460d0889de7a93c16212bf Mon Sep 17 00:00:00 2001 From: lmittmann Date: Wed, 2 Apr 2025 11:37:18 +0200 Subject: [PATCH 10/11] added more funcs --- internal/fourbyte/funcs.go | 11 +++++++++++ internal/fourbyte/funcs.txt | 11 +++++++++++ 2 files changed, 22 insertions(+) diff --git a/internal/fourbyte/funcs.go b/internal/fourbyte/funcs.go index 76bb544c..4f1dd3be 100644 --- a/internal/fourbyte/funcs.go +++ b/internal/fourbyte/funcs.go @@ -16,6 +16,7 @@ var functions = map[[4]byte]*w3.Func{ {0x02, 0x75, 0x1c, 0xec}: w3.MustNewFunc("removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline)", "uint256 amountToken, uint256 amountETH"), {0x02, 0xcc, 0x25, 0x0d}: w3.MustNewFunc("isSolver(address)", "bool"), {0x03, 0xa1, 0xc0, 0xbb}: w3.MustNewFunc("PoolFunctionNotImplemented()", ""), + {0x04, 0xe4, 0x5a, 0xaf}: w3.MustNewFunc("exactInputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96) params)", "uint256 amountOut"), {0x05, 0x4d, 0x50, 0xd4}: w3.MustNewFunc("getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut)", "uint256 amountOut"), {0x05, 0x8a, 0x62, 0x8f}: w3.MustNewFunc("setAuthorizer(address newAuthorizer)", ""), {0x06, 0x7d, 0x92, 0x74}: w3.MustNewFunc("buyGemNoFee(address usr, uint256 gemAmt)", "uint256 daiInWad"), @@ -28,6 +29,7 @@ var functions = map[[4]byte]*w3.Func{ {0x09, 0x02, 0xf1, 0xac}: w3.MustNewFunc("getReserves()", "uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast"), {0x09, 0x5e, 0xa7, 0xb3}: w3.MustNewFunc("approve(address spender, uint256 amount)", "bool success"), {0x09, 0x78, 0x52, 0x5c}: w3.MustNewFunc("createPermissioned(uint64 feeAIn, uint64 feeBIn, uint16 tickSpacing, uint32 lookback, address tokenA, address tokenB, int32 activeTick, uint8 kinds, address accessor, bool permissionedLiquidity, bool permissionedSwap)", "address pool"), + {0x09, 0xb8, 0x13, 0x46}: w3.MustNewFunc("exactOutput((bytes path, address recipient, uint256 amountOut, uint256 amountInMaximum) params)", "uint256 amountIn"), {0x0a, 0x28, 0xa4, 0x77}: w3.MustNewFunc("previewWithdraw(uint256 assets)", "uint256 shares"), {0x0a, 0x5f, 0x0b, 0x03}: w3.MustNewFunc("createPermissioned(uint64 feeAIn, uint64 feeBIn, uint16 tickSpacing, uint32 lookback, address tokenA, address tokenB, int32 activeTick, uint8 kinds, address accessor)", "address"), {0x0b, 0x0d, 0x9c, 0x09}: w3.MustNewFunc("take(address currency, address to, uint256 amount)", ""), @@ -67,6 +69,7 @@ var functions = map[[4]byte]*w3.Func{ {0x1e, 0x09, 0x21, 0x04}: w3.MustNewFunc("PermissionDenied()", ""), {0x1e, 0x2e, 0xae, 0xaf}: w3.MustNewFunc("extsload(bytes32 slot)", "bytes32 value"), {0x1f, 0x00, 0xca, 0x74}: w3.MustNewFunc("getAmountsIn(uint256 amountOut, address[] path)", "uint256[] amounts"), + {0x1f, 0x04, 0x64, 0xd1}: w3.MustNewFunc("multicall(bytes32 previousBlockhash, bytes[] data)", "bytes[] results"), {0x20, 0x81, 0x06, 0x6c}: w3.MustNewFunc("initial_A_time()", "uint256"), {0x20, 0xdb, 0x82, 0x67}: w3.MustNewFunc("InvalidPath()", ""), {0x21, 0x27, 0x2d, 0x4c}: w3.MustNewFunc("tokenBScale()", "uint256"), @@ -139,6 +142,7 @@ var functions = map[[4]byte]*w3.Func{ {0x40, 0xd9, 0xc0, 0xe3}: w3.MustNewFunc("trim()", "uint256 wad"), {0x40, 0xfb, 0x07, 0xa0}: w3.MustNewFunc("buyAsset(uint256 minAmount, address receiver)", "uint256, uint256"), {0x41, 0x4b, 0xf3, 0x89}: w3.MustNewFunc("exactInputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96) params)", "uint256 amountOut"), + {0x42, 0x71, 0x2a, 0x67}: w3.MustNewFunc("swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] path, address to)", "uint256 amountIn"), {0x42, 0x84, 0x2e, 0x0e}: w3.MustNewFunc("safeTransferFrom(address from, address to, uint256 tokenId)", ""), {0x42, 0x96, 0x6c, 0x68}: w3.MustNewFunc("burn(uint256)", ""), {0x42, 0xe3, 0xd7, 0x2c}: w3.MustNewFunc("addLiquidity(address recipient, uint256 subaccount, (uint8 kind, int32[] ticks, uint128[] amounts) params, bytes data)", "uint256 tokenAAmount, uint256 tokenBAmount, uint32[] binIds"), @@ -148,6 +152,7 @@ var functions = map[[4]byte]*w3.Func{ {0x46, 0x0d, 0xd9, 0x49}: w3.MustNewFunc("settleBatch((address taker, address receiver, uint256 expiry, uint256 nonce, address executor, uint16 minFillPercent, bytes32 hooksHash, address[] sellTokens, address[] buyTokens, uint256[] sellAmounts, uint256[] buyAmounts, uint256[] sellNFTIds, uint256[] buyNFTIds, bytes sellTokenTransfers, bytes buyTokenTransfers)[] orders, (uint8 type, bytes signatureBytes)[] signatures, (bytes[] permitSignatures, bytes signatureBytesPermit2, uint48[] noncesPermit2, uint48 deadline)[] takersPermitsInfo, (bool result, address to, uint256 value, bytes data)[] interactions, ((bool result, address to, uint256 value, bytes data)[] beforeSettle, (bool result, address to, uint256 value, bytes data)[] afterSettle)[] hooks, (address balanceRecipient, uint16[] curFillPercents, bool[] takersPermitsUsage, bool transferExactAmounts) solverData)", ""), {0x46, 0x14, 0x13, 0x19}: w3.MustNewFunc("feeGrowthGlobal1X128()", "uint256"), {0x46, 0x8d, 0x01, 0x82}: w3.MustNewFunc("PoolKindNotSupported(uint256 kinds, uint256 kind)", ""), + {0x47, 0x2b, 0x43, 0xf3}: w3.MustNewFunc("swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] path, address to)", "uint256 amountOut"), {0x47, 0xaa, 0xf0, 0x7a}: w3.MustNewFunc("SliceOverflow()", ""), {0x48, 0x3a, 0x69, 0x29}: w3.MustNewFunc("InvalidOwnerERC1155()", ""), {0x48, 0x5c, 0xc9, 0x55}: w3.MustNewFunc("initialize(address token0, address token1)", ""), @@ -168,6 +173,7 @@ var functions = map[[4]byte]*w3.Func{ {0x4c, 0xda, 0xd5, 0x06}: w3.MustNewFunc("previewRedeem(uint256 shares)", "uint256 assets"), {0x4d, 0xce, 0xbc, 0xba}: w3.MustNewFunc("swapSingle((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount)", ""), {0x4e, 0x48, 0x7b, 0x71}: w3.MustNewFunc("Panic(uint256)", ""), + {0x50, 0x23, 0xb4, 0xdf}: w3.MustNewFunc("exactOutputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 amountOut, uint256 amountInMaximum, uint160 sqrtPriceLimitX96) params)", "uint256 amountIn"), {0x50, 0xfd, 0xc0, 0xac}: w3.MustNewFunc("PoolMigrateBinFirst()", ""), {0x51, 0x49, 0xe7, 0x95}: w3.MustNewFunc("PayerSpent()", ""), {0x52, 0x75, 0x96, 0x51}: w3.MustNewFunc("updateDynamicLPFee((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint24 newDynamicLPFee)", ""), @@ -187,6 +193,7 @@ var functions = map[[4]byte]*w3.Func{ {0x59, 0x21, 0xc8, 0xe0}: w3.MustNewFunc("burnAfterSeize(uint256 amount)", "uint256"), {0x5a, 0x3d, 0x54, 0x93}: w3.MustNewFunc("price1CumulativeLast()", "uint256"), {0x5a, 0x6b, 0xcf, 0xda}: w3.MustNewFunc("modifyLiquidity((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, bytes hookData)", "int256 callerDelta, int256 feesAccrued"), + {0x5a, 0xe4, 0x01, 0xdc}: w3.MustNewFunc("multicall(uint256 deadline, bytes[] data)", "bytes[] results"), {0x5b, 0x08, 0xba, 0x18}: w3.MustNewFunc("ERC721InvalidOperator(address operator)", ""), {0x5b, 0x0d, 0x59, 0x84}: w3.MustNewFunc("removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s)", "uint256 amountETH"), {0x5b, 0x41, 0xb9, 0x08}: w3.MustNewFunc("exchange(uint256 i, uint256 j, uint256 dx, uint256 min_dy)", ""), @@ -356,14 +363,17 @@ var functions = map[[4]byte]*w3.Func{ {0xb3, 0x09, 0x38, 0x38}: w3.MustNewFunc("fillQuoteTokenToEthWithPermit(address sellTokenAddress, address target, bytes swapCallData, uint256 sellAmount, uint256 feePercentageBasisPoints, (uint256 value, uint256 nonce, uint256 deadline, bool isDaiStylePermit, uint8 v, bytes32 r, bytes32 s) permitData)", ""), {0xb3, 0xbc, 0xfa, 0x82}: w3.MustNewFunc("dec()", "uint256"), {0xb3, 0xd7, 0xf6, 0xb9}: w3.MustNewFunc("previewMint(uint256 shares)", "uint256 assets"), + {0xb4, 0x55, 0x42, 0x31}: w3.MustNewFunc("exactInputStableSwap(address[] path, uint256[] flag, uint256 amountIn, uint256 amountOutMin, address to)", "uint256 amountOut"), {0xb4, 0x60, 0xaf, 0x94}: w3.MustNewFunc("withdraw(uint256 assets, address receiver, address owner)", "uint256 shares"), {0xb4, 0x7b, 0x2f, 0xb1}: w3.MustNewFunc("afterSwap(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96) params, int256 delta, bytes hookData)", "bytes4, int128"), {0xb4, 0xb5, 0x77, 0xad}: w3.MustNewFunc("future_A()", "uint256"), {0xb4, 0xb9, 0xd1, 0xf1}: w3.MustNewFunc("lookup(uint256 startIndex, uint256 endIndex)", "address[] pools"), + {0xb4, 0xc4, 0xe5, 0x55}: w3.MustNewFunc("exactOutputStableSwap(address[] path, uint256[] flag, uint256 amountOut, uint256 amountInMax, address to)", "uint256 amountIn"), {0xb4, 0xc9, 0x91, 0xc6}: w3.MustNewFunc("poolByTokenCount(address _tokenA, address _tokenB, address accessor)", "uint256 _poolCount"), {0xb5, 0xc7, 0x36, 0xe4}: w3.MustNewFunc("readFromStorage(bytes32 slot)", "uint256 result"), {0xb6, 0xa8, 0xb0, 0xfa}: w3.MustNewFunc("beforeDonate(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint256 amount0, uint256 amount1, bytes hookData)", "bytes4"), {0xb6, 0xf9, 0xde, 0x95}: w3.MustNewFunc("swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] path, address to, uint256 deadline)", ""), + {0xb8, 0x58, 0x18, 0x3f}: w3.MustNewFunc("exactInput((bytes path, address recipient, uint256 amountIn, uint256 amountOutMinimum) params)", "uint256 amountOut"), {0xb8, 0x8d, 0x4f, 0xde}: w3.MustNewFunc("safeTransferFrom(address from, address to, uint256 tokenId, bytes data)", ""), {0xb9, 0x48, 0x0d, 0x4a}: w3.MustNewFunc("protocolFeeA()", "uint128"), {0xba, 0x08, 0x76, 0x52}: w3.MustNewFunc("redeem(uint256 shares, address receiver, address owner)", "uint256 assets"), @@ -481,6 +491,7 @@ var functions = map[[4]byte]*w3.Func{ {0xfb, 0x77, 0x2a, 0x88}: w3.MustNewFunc("ZeroSellAmount(address token)", ""), {0xfb, 0x8f, 0x41, 0xb2}: w3.MustNewFunc("ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed)", ""), {0xfc, 0x0c, 0x54, 0x6a}: w3.MustNewFunc("token()", "address"), + {0xfc, 0xc9, 0x13, 0x6c}: w3.MustNewFunc("pairLength()", "uint256"), {0xfd, 0x06, 0x84, 0xb1}: w3.MustNewFunc("stored_rates()", "uint256[]"), {0xfd, 0xef, 0x91, 0x06}: w3.MustNewFunc("hasPermission(address who, address where, bytes32 what, bytes how)", "bool"), {0xfe, 0xaf, 0x96, 0x8c}: w3.MustNewFunc("latestRoundData()", "uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound"), diff --git a/internal/fourbyte/funcs.txt b/internal/fourbyte/funcs.txt index e4c2aa30..0ae1035f 100644 --- a/internal/fourbyte/funcs.txt +++ b/internal/fourbyte/funcs.txt @@ -104,10 +104,16 @@ ERC721InvalidSender(address sender) ERC721NonexistentToken(uint256 tokenId) Error(string) ETHNotAccepted() +exactInput((bytes path, address recipient, uint256 amountIn, uint256 amountOutMinimum) params) uint256 amountOut exactInput((bytes path, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum) params) uint256 amountOut +exactInputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96) params) uint256 amountOut exactInputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96) params) uint256 amountOut +exactInputStableSwap(address[] path, uint256[] flag, uint256 amountIn, uint256 amountOutMin, address to) uint256 amountOut +exactOutput((bytes path, address recipient, uint256 amountOut, uint256 amountInMaximum) params) uint256 amountIn exactOutput((bytes path, address recipient, uint256 deadline, uint256 amountOut, uint256 amountInMaximum) params) uint256 amountIn +exactOutputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 amountOut, uint256 amountInMaximum, uint160 sqrtPriceLimitX96) params) uint256 amountIn exactOutputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountOut, uint256 amountInMaximum, uint160 sqrtPriceLimitX96) params) uint256 amountIn +exactOutputStableSwap(address[] path, uint256[] flag, uint256 amountOut, uint256 amountInMax, address to) uint256 amountIn exchange(int128 i, int128 j, uint256 dx, uint256 min_dy) exchange(int128 i, int128 j, uint256 dx, uint256 min_dy, address receiver) exchange(uint256 i, uint256 j, uint256 dx, uint256 min_dy) @@ -249,7 +255,9 @@ mint(uint256 shares, address receiver) uint256 assets mint(uint256) mint_relative(address to, uint256 frac) uint256 modifyLiquidity((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, bytes hookData) int256 callerDelta, int256 feesAccrued +multicall(bytes32 previousBlockhash, bytes[] data) bytes[] results multicall(bytes[] data) bytes[] results +multicall(uint256 deadline, bytes[] data) bytes[] results N_COINS() uint256 name() string newton_D(uint256 ANN, uint256 gamma, uint256[3] x_unsorted, uint256 K0_prev) uint256 @@ -261,6 +269,7 @@ onERC721Received(address operator, address from, uint256 tokenId, bytes data) by onSwap((uint8 kind, address tokenIn, address tokenOut, uint256 amount, bytes32 poolId, uint256 lastChangeBlock, address from, address to, bytes userData) swapRequest, uint256[] balances, uint256 indexIn, uint256 indexOut) uint256 amount owner() address ownerOf(uint256 tokenId) address +pairLength() uint256 pancakeV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes data) Panic(uint256) paused() bool @@ -401,6 +410,7 @@ swapExactETHForTokens(uint256 amountOutMin, address[] path, address to, uint256 swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] path, address to, uint256 deadline) swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline) uint256[] amounts swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline) +swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] path, address to) uint256 amountOut swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline) uint256[] amounts swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline) swapMulti((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address[] takerTokens, address[] makerTokens, uint256[] takerAmounts, uint256[] makerAmounts, address receiver, bytes commands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount) @@ -408,6 +418,7 @@ swapSingle((uint256 expiry, address takerAddress, address makerAddress, uint256 swapSingleFromContract((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature) swapTargets(address) bool swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] path, address to, uint256 deadline) uint256[] amounts +swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] path, address to) uint256 amountIn swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] path, address to, uint256 deadline) uint256[] amounts sweepToken(address token, uint256 amountMinimum, address recipient) sweepTokenAmount(address token, uint256 amount, address recipient) From 3c8334857c323318ea10e8d91d396aae78566258 Mon Sep 17 00:00:00 2001 From: lmittmann Date: Wed, 2 Apr 2025 11:43:02 +0200 Subject: [PATCH 11/11] add more funcs --- internal/fourbyte/funcs.go | 11 +++++++++++ internal/fourbyte/funcs.txt | 11 +++++++++++ 2 files changed, 22 insertions(+) diff --git a/internal/fourbyte/funcs.go b/internal/fourbyte/funcs.go index 4f1dd3be..6804be3d 100644 --- a/internal/fourbyte/funcs.go +++ b/internal/fourbyte/funcs.go @@ -19,6 +19,7 @@ var functions = map[[4]byte]*w3.Func{ {0x04, 0xe4, 0x5a, 0xaf}: w3.MustNewFunc("exactInputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96) params)", "uint256 amountOut"), {0x05, 0x4d, 0x50, 0xd4}: w3.MustNewFunc("getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut)", "uint256 amountOut"), {0x05, 0x8a, 0x62, 0x8f}: w3.MustNewFunc("setAuthorizer(address newAuthorizer)", ""), + {0x06, 0x50, 0x91, 0xdb}: w3.MustNewFunc("verifyCallback(address deployer, (address token0, address token1, uint24 fee) poolKey)", "address pool"), {0x06, 0x7d, 0x92, 0x74}: w3.MustNewFunc("buyGemNoFee(address usr, uint256 gemAmt)", "uint256 daiInWad"), {0x06, 0xfd, 0xde, 0x03}: w3.MustNewFunc("name()", "string"), {0x07, 0x21, 0x1e, 0xf7}: w3.MustNewFunc("get_dy_underlying(int128 i, int128 j, uint256 amount)", "uint256"), @@ -58,6 +59,7 @@ var functions = map[[4]byte]*w3.Func{ {0x18, 0x65, 0xc5, 0x7d}: w3.MustNewFunc("getState()", "(uint128 reserveA, uint128 reserveB, int64 lastTwaD8, int64 lastLogPriceD8, uint40 lastTimestamp, int32 activeTick, bool isLocked, uint32 binCounter, uint8 protocolFeeRatioD3)"), {0x18, 0xcb, 0xaf, 0xe5}: w3.MustNewFunc("swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline)", "uint256[] amounts"), {0x18, 0xfd, 0xd0, 0x6b}: w3.MustNewFunc("getGrossAmountFromTotalSold(uint256 totalAmount)", "uint256"), + {0x19, 0x21, 0x28, 0xb2}: w3.MustNewFunc("getAmountsIn(address factory, uint256 amountOut, address[] path)", "uint256[] amounts"), {0x1a, 0x49, 0x90, 0x26}: w3.MustNewFunc("settleSingle((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount, (bool useOldAmount, uint256 makerAmount, uint256 makerNonce) takerQuoteInfo, bytes takerSignature)", ""), {0x1a, 0x68, 0x65, 0x02}: w3.MustNewFunc("liquidity()", "uint128"), {0x1b, 0x9a, 0x91, 0xa4}: w3.MustNewFunc("withdrawEth(address to, uint256 amount)", ""), @@ -89,6 +91,7 @@ var functions = map[[4]byte]*w3.Func{ {0x29, 0x35, 0x77, 0x50}: w3.MustNewFunc("N_COINS()", "uint256"), {0x29, 0x69, 0xe0, 0x4a}: w3.MustNewFunc("remove_liquidity(uint256 burn_amount, uint256[] min_amounts, address receiver, bool claim_admin_fees)", "uint256[]"), {0x2a, 0x2d, 0x80, 0xd1}: w3.MustNewFunc("permit(address owner, ((address token, uint160 amount, uint48 expiration, uint48 nonce)[] details, address spender, uint256 sigDeadline) permitBatch, bytes signature)", ""), + {0x2b, 0x6d, 0x5d, 0x8f}: w3.MustNewFunc("getPoolKey(address tokenA, address tokenB, uint24 fee)", "(address token0, address token1, uint24 fee)"), {0x2c, 0x40, 0x29, 0xe9}: w3.MustNewFunc("ExecutionFailed(uint256 commandIndex, bytes message)", ""), {0x2c, 0x50, 0xf4, 0xbe}: w3.MustNewFunc("PoolValueExceedsBits(uint256 amount, uint256 bits)", ""), {0x2d, 0x77, 0x13, 0x89}: w3.MustNewFunc("setProtocolFeeController(address controller)", ""), @@ -102,6 +105,7 @@ var functions = map[[4]byte]*w3.Func{ {0x31, 0xad, 0x53, 0xfa}: w3.MustNewFunc("protocolLendingFeeRateD18()", "uint256"), {0x32, 0x56, 0xcf, 0xa9}: w3.MustNewFunc("getTick(int32 tick)", "(uint128 reserveA, uint128 reserveB, uint128 totalSupply, uint32[4] binIdsByTick) tickState"), {0x32, 0x68, 0xf2, 0xb9}: w3.MustNewFunc("lookupPermissioned(address _tokenA, address _tokenB, address accessor, uint256 startIndex, uint256 endIndex)", "address[] pools"), + {0x32, 0x74, 0x94, 0x61}: w3.MustNewFunc("getReserves(address factory, address tokenA, address tokenB)", "uint256 reserveA, uint256 reserveB"), {0x32, 0xb1, 0x3d, 0x91}: w3.MustNewFunc("V3InvalidCaller()", ""), {0x33, 0x51, 0xb2, 0x60}: w3.MustNewFunc("DeltaNotNegative(address token)", ""), {0x35, 0x93, 0x56, 0x4c}: w3.MustNewFunc("execute(bytes commands, bytes[] inputs, uint256 deadline)", ""), @@ -173,6 +177,7 @@ var functions = map[[4]byte]*w3.Func{ {0x4c, 0xda, 0xd5, 0x06}: w3.MustNewFunc("previewRedeem(uint256 shares)", "uint256 assets"), {0x4d, 0xce, 0xbc, 0xba}: w3.MustNewFunc("swapSingle((uint256 expiry, address takerAddress, address makerAddress, uint256 makerNonce, address takerToken, address makerToken, uint256 takerAmount, uint256 makerAmount, address receiver, uint256 packedCommands, uint256 flags) order, (bytes signatureBytes, uint256 flags) makerSignature, uint256 filledTakerAmount)", ""), {0x4e, 0x48, 0x7b, 0x71}: w3.MustNewFunc("Panic(uint256)", ""), + {0x4e, 0x6c, 0x8e, 0xd8}: w3.MustNewFunc("getPool(address deployer, address tokenA, address tokenB, uint24 fee)", "address"), {0x50, 0x23, 0xb4, 0xdf}: w3.MustNewFunc("exactOutputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 amountOut, uint256 amountInMaximum, uint160 sqrtPriceLimitX96) params)", "uint256 amountIn"), {0x50, 0xfd, 0xc0, 0xac}: w3.MustNewFunc("PoolMigrateBinFirst()", ""), {0x51, 0x49, 0xe7, 0x95}: w3.MustNewFunc("PayerSpent()", ""), @@ -182,6 +187,7 @@ var functions = map[[4]byte]*w3.Func{ {0x52, 0xf7, 0xc9, 0x88}: w3.MustNewFunc("setFee(uint256 newFeeAIn, uint256 newFeeBIn)", ""), {0x54, 0x09, 0x49, 0x1a}: w3.MustNewFunc("initial_A()", "uint256"), {0x54, 0x0d, 0x49, 0x18}: w3.MustNewFunc("lmPool()", "address"), + {0x54, 0x4c, 0xaa, 0x56}: w3.MustNewFunc("sortTokens(address tokenA, address tokenB)", "address token0, address token1"), {0x54, 0xfd, 0x4d, 0x50}: w3.MustNewFunc("version()", "uint256"), {0x55, 0x1a, 0x65, 0x88}: w3.MustNewFunc("stop_ramp_A()", ""), {0x55, 0xe4, 0xb7, 0xbe}: w3.MustNewFunc("fillQuoteTokenToToken(address sellTokenAddress, address buyTokenAddress, address target, bytes swapCallData, uint256 sellAmount, uint256 feeAmount)", ""), @@ -191,6 +197,7 @@ var functions = map[[4]byte]*w3.Func{ {0x57, 0x8e, 0xac, 0xa4}: w3.MustNewFunc("isFactoryPool(address pool)", "bool"), {0x59, 0x09, 0xc0, 0xd5}: w3.MustNewFunc("price0CumulativeLast()", "uint256"), {0x59, 0x21, 0xc8, 0xe0}: w3.MustNewFunc("burnAfterSeize(uint256 amount)", "uint256"), + {0x59, 0x23, 0xca, 0xb3}: w3.MustNewFunc("getStableAmountsIn(address stableSwapFactory, address stableSwapInfo, address[] path, uint256[] flag, uint256 amountOut)", "uint256[] amounts"), {0x5a, 0x3d, 0x54, 0x93}: w3.MustNewFunc("price1CumulativeLast()", "uint256"), {0x5a, 0x6b, 0xcf, 0xda}: w3.MustNewFunc("modifyLiquidity((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, bytes hookData)", "int256 callerDelta, int256 feesAccrued"), {0x5a, 0xe4, 0x01, 0xdc}: w3.MustNewFunc("multicall(uint256 deadline, bytes[] data)", "bytes[] results"), @@ -229,6 +236,7 @@ var functions = map[[4]byte]*w3.Func{ {0x6a, 0x12, 0xf1, 0x04}: w3.MustNewFunc("InsufficientETH()", ""), {0x6c, 0x2b, 0xbe, 0x7e}: w3.MustNewFunc("afterRemoveLiquidity(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, (int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt) params, int256 delta, int256 feesAccrued, bytes hookData)", "bytes4, int256"), {0x6d, 0x54, 0x33, 0xe6}: w3.MustNewFunc("max(uint256, uint256)", "uint256"), + {0x6d, 0x91, 0xc0, 0xe2}: w3.MustNewFunc("pairFor(address factory, address tokenA, address tokenB)", "address pair"), {0x6e, 0x55, 0x3f, 0x65}: w3.MustNewFunc("deposit(uint256 assets, address receiver)", "uint256 shares"), {0x6e, 0x99, 0x60, 0xc3}: w3.MustNewFunc("getAdmin()", "address"), {0x6f, 0x5f, 0xfb, 0x7e}: w3.MustNewFunc("ContractLocked()", ""), @@ -271,6 +279,7 @@ var functions = map[[4]byte]*w3.Func{ {0x81, 0xd1, 0x8d, 0x87}: w3.MustNewFunc("wad_exp(int256 power)", "uint256"), {0x82, 0x5c, 0xab, 0xa1}: w3.MustNewFunc("cancelOrderRFQ(uint256 orderInfo)", ""), {0x82, 0xd5, 0xd7, 0x6a}: w3.MustNewFunc("InvalidTarget()", ""), + {0x83, 0x09, 0x2a, 0x82}: w3.MustNewFunc("computeAddress(address deployer, (address token0, address token1, uint24 fee) key)", "address pool"), {0x83, 0xc4, 0xa1, 0x9d}: w3.MustNewFunc("swapTargets(address)", "bool"), {0x84, 0x9e, 0xaf, 0x98}: w3.MustNewFunc("V2TooLittleReceived()", ""), {0x84, 0xae, 0x11, 0x48}: w3.MustNewFunc("RouterTooLittleReceived(uint256 amountOutMinimum, uint256 amountOut)", ""), @@ -287,6 +296,7 @@ var functions = map[[4]byte]*w3.Func{ {0x89, 0xc6, 0x2b, 0x64}: w3.MustNewFunc("ERC721InvalidOwner(address owner)", ""), {0x8a, 0x52, 0xcc, 0xc2}: w3.MustNewFunc("poolPermissionedCount()", "uint256 _poolCount"), {0x8a, 0xb0, 0xbc, 0x16}: w3.MustNewFunc("V2TooMuchRequested()", ""), + {0x8b, 0xdb, 0x19, 0x25}: w3.MustNewFunc("verifyCallback(address deployer, address tokenA, address tokenB, uint24 fee)", "address pool"), {0x8c, 0x25, 0x25, 0xfe}: w3.MustNewFunc("PoolSenderNotAccessor(address sender, address accessor)", ""), {0x8d, 0x7e, 0xf9, 0xbb}: w3.MustNewFunc("buyGem(address usr, uint256 gemAmt)", "uint256 daiInWad"), {0x8d, 0xa5, 0xcb, 0x5b}: w3.MustNewFunc("owner()", "address"), @@ -373,6 +383,7 @@ var functions = map[[4]byte]*w3.Func{ {0xb5, 0xc7, 0x36, 0xe4}: w3.MustNewFunc("readFromStorage(bytes32 slot)", "uint256 result"), {0xb6, 0xa8, 0xb0, 0xfa}: w3.MustNewFunc("beforeDonate(address sender, (address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint256 amount0, uint256 amount1, bytes hookData)", "bytes4"), {0xb6, 0xf9, 0xde, 0x95}: w3.MustNewFunc("swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] path, address to, uint256 deadline)", ""), + {0xb7, 0x35, 0xae, 0xcd}: w3.MustNewFunc("getStableInfo(address stableSwapFactory, address input, address output, uint256 flag)", "uint256 i, uint256 j, address swapContract"), {0xb8, 0x58, 0x18, 0x3f}: w3.MustNewFunc("exactInput((bytes path, address recipient, uint256 amountIn, uint256 amountOutMinimum) params)", "uint256 amountOut"), {0xb8, 0x8d, 0x4f, 0xde}: w3.MustNewFunc("safeTransferFrom(address from, address to, uint256 tokenId, bytes data)", ""), {0xb9, 0x48, 0x0d, 0x4a}: w3.MustNewFunc("protocolFeeA()", "uint128"), diff --git a/internal/fourbyte/funcs.txt b/internal/fourbyte/funcs.txt index 0ae1035f..a90543ee 100644 --- a/internal/fourbyte/funcs.txt +++ b/internal/fourbyte/funcs.txt @@ -59,6 +59,7 @@ claimProtocolFeeForPool(address pool, bool isTokenA) clear(address currency, uint256 amount) coins(uint256 i) address collectProtocolFees(address recipient, address currency, uint256 amount) uint256 amountCollected +computeAddress(address deployer, (address token0, address token1, uint24 fee) key) address pool ConfusedDeputy() ContractLocked() convertToAssets(uint256 shares) uint256 assets @@ -167,6 +168,7 @@ get_y(uint256 ANN, uint256 gamma, uint256[3] x, uint256 D, uint256 i) uint256[2] getAdmin() address getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) uint256 amountIn getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) uint256 amountOut +getAmountsIn(address factory, uint256 amountOut, address[] path) uint256[] amounts getAmountsIn(uint256 amountOut, address[] path) uint256[] amounts getAmountsOut(uint256 amountIn, address[] path) uint256[] amounts getApp(bytes32 namespace, bytes32 appId) address @@ -183,13 +185,18 @@ getGrossAmountFromTotalSold(uint256 totalAmount) uint256 getImplementationSigs(address impl) bytes4[] getInternalBalance(address user, address[] tokens) uint256[] getPair(address tokenA, address tokenB) address pair +getPool(address deployer, address tokenA, address tokenB, uint24 fee) address +getPoolKey(address tokenA, address tokenB, uint24 fee) (address token0, address token1, uint24 fee) getReserves() uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast +getReserves(address factory, address tokenA, address tokenB) uint256 reserveA, uint256 reserveB getRoleAdmin(bytes32 role) bytes32 getRoleMember(bytes32 role, uint256 index) address getRoleMemberCount(bytes32 role) uint256 getRoundData(uint80 roundId) uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound getSellFee(uint256 grossAmount) uint256 getSigsImplementation(bytes4 sig) address +getStableAmountsIn(address stableSwapFactory, address stableSwapInfo, address[] path, uint256[] flag, uint256 amountOut) uint256[] amounts +getStableInfo(address stableSwapFactory, address input, address output, uint256 flag) uint256 i, uint256 j, address swapContract getState() (uint128 reserveA, uint128 reserveB, int64 lastTwaD8, int64 lastLogPriceD8, uint40 lastTimestamp, int32 activeTick, bool isLocked, uint32 binCounter, uint8 protocolFeeRatioD3) getTick(int32 tick) (uint128 reserveA, uint128 reserveB, uint128 totalSupply, uint32[4] binIdsByTick) tickState grantRole(bytes32 role, address account) @@ -269,6 +276,7 @@ onERC721Received(address operator, address from, uint256 tokenId, bytes data) by onSwap((uint8 kind, address tokenIn, address tokenOut, uint256 amount, bytes32 poolId, uint256 lastChangeBlock, address from, address to, bytes userData) swapRequest, uint256[] balances, uint256 indexIn, uint256 indexOut) uint256 amount owner() address ownerOf(uint256 tokenId) address +pairFor(address factory, address tokenA, address tokenB) address pair pairLength() uint256 pancakeV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes data) Panic(uint256) @@ -389,6 +397,7 @@ skim(address to) SliceOutOfBounds() SliceOverflow() slot0() (uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint8 feeProtocol, bool unlocked) +sortTokens(address tokenA, address tokenB) address token0, address token1 stake(uint256 amount, uint256 term) stop_ramp_A() stored_rates() uint256[] @@ -478,6 +487,8 @@ V3InvalidCaller() V3InvalidSwap() V3TooLittleReceived() V3TooMuchRequested() +verifyCallback(address deployer, (address token0, address token1, uint24 fee) poolKey) address pool +verifyCallback(address deployer, address tokenA, address tokenB, uint24 fee) address pool version() uint256 wad_exp(int256 power) uint256 weth() address