From 4ca6b6d567e9e4dd058319f1b39d005edc9abecb Mon Sep 17 00:00:00 2001 From: jpsains <32621022+jpsains@users.noreply.github.com> Date: Mon, 2 Dec 2024 09:59:55 +0000 Subject: [PATCH 1/4] feat: mendi-finance (#383) --- linea.db | Bin 221184 -> 221184 bytes .../src/adapters/integration.test.ts | 2 + .../mendi-finance/contracts/SMendi.ts | 970 ++++++++++++++++++ .../mendi-finance/contracts/abis/sMendi.json | 1 + .../contracts/factories/SMendi__factory.ts | 874 ++++++++++++++++ .../contracts/factories/index.ts | 1 + .../adapters/mendi-finance/contracts/index.ts | 2 + .../staking/mendiFinanceStakingAdapter.ts | 209 ++++ .../snapshots/linea.positions.staking.json | 115 +++ .../products/staking/tests/testCases.ts | 26 + .../src/adapters/supportedProtocols.ts | 3 + 11 files changed, 2203 insertions(+) create mode 100644 packages/adapters-library/src/adapters/mendi-finance/contracts/SMendi.ts create mode 100644 packages/adapters-library/src/adapters/mendi-finance/contracts/abis/sMendi.json create mode 100644 packages/adapters-library/src/adapters/mendi-finance/contracts/factories/SMendi__factory.ts create mode 100644 packages/adapters-library/src/adapters/mendi-finance/products/staking/mendiFinanceStakingAdapter.ts create mode 100644 packages/adapters-library/src/adapters/mendi-finance/products/staking/tests/snapshots/linea.positions.staking.json create mode 100644 packages/adapters-library/src/adapters/mendi-finance/products/staking/tests/testCases.ts diff --git a/linea.db b/linea.db index 84f6ca074ddb2f475f974f75af434e770aad88e7..ad0e4f3da76b54cb1ffb01ab57797a32c0af7b94 100644 GIT binary patch delta 3381 zcmb_e3vg8B6~5=c&%L|%-XtWF7jY3Gu$#cWo6TlZAlX+!ct|KFL>yzYNmfNL8z2L* zmJ$j`w}Lm}3cng0gP_*d(%>o=tJ4~_YAa%lC~xYc9d%R+#Xhth+yCAGBQu?8oayfD z{@*$OIp?1LJpOxnUXXfTka`QCp|3Cs4f|X6Ds+xqZ15S=kX)SBGX5&%=hiV)alsvl zj`n4xw=C<3ceEu|cg2@4>$o)?E_w-abL6R%GEwf6*U7iZ*DIeWvy`I>mZzrk-7Yyl zk0~yI|E64*j!b_vv#gGyC>QzJACacVqt0Y<#cDXhDj!mua@68aQ9dRnPb*(3XO%CM zx6=8cUnz8v?l+FsyU8l2zp96N+_?ryV7oE(;Zub!sh3jjSK1X-{+Ilke4pGRmnes% ze@HJ&z2s1x(t6(n2E{Ysh}s<}EAv-I!sRtuZH4A5_a&mS@<2_nwz6D}Y2k7$81buW zYe2ngov-kcPFtJLR~rb20~(QO^~Kdhu(GDs=L@P8m2Hu-gcdB*TD6!)bP6u%_{(a7 zLA5dwukZ(J@GwS2>C$~if%v+Xk|pIKWw}zR@bWwI9(ko)EuECsN>319o22C$F#+Gk z)d`n1#_DL{MGZWJkp~LW(y#xn!CZqqR{^py^W4ow|G6)j!!zhOUb!B;9RGU)5q`KH zJRJW!3mXGb0$;Y_4`T!l+3@|%1iod%^GyT}TM(~&7J1Si{$(Pt?~Ky9;7ON#;pXZ0 zsOk9iBHFX3=byA{?Wx^bx!S5F%C(BJV6?qfZHwNL@K^ZCEB(=cue~A`P%HeEJ}nyN z-%byH-7pbqG3$nzNb1EQH!L>qbHir~+M#*LW@i@A9`k}9HURs&&FGWCW9|vS zHV#HiZ8mfuc+(uHhIThSo9@Sa3p7sQV|)g8iu)61J zuog64w}tcYd)vUv-)j@r(>(&S%_hbh@jD2yRV6kd$J#N!Tni2%|9&b4!-$p97wARi z6!SBto2g~8=?~~ZoZkaoW^WG&h@+=a9^@uAuH|fV79{3&*n|})56|4kuA+W|Fl>Y= zxThIdp2->IoXDlP*nY`el zN+FNJxx-Kxl9H}$=W*vw@o!>UEOH!nY*o4xulxtukmpLDAk`5PE(iyOwL+PgbT&xi zU2nKj%5(53JO-`A$Y5XJ0-;&=v+<@0fUQdmZ!yvI^@Udr z&aP$24)=nk3vX~YB$p>Tk`~Mg>r2@9v~k4H7-}Kker+yT){%(2mn2ps+mfpi3zkH) zB6_3IJU_A^qF>L(ClmL^{93r4j4FwC_jT6zvfBR7s@LbR@!18qhoQZ=+(d4sRWD@m zIRtU@qY;?QGR`Wh7-t-VNlaK@z~VnIMIpLMpO6228bUA+ht5Edo~O?>)`#cObM-ny zj?BedkHeqfI{b@gP#C9Az&%B-8>y?}^DSQ^<*kWWyWgjhL84k;$i^q-fH8502S4}> z%3wlzF^k`5Le=>AN!Y+h2dNpj?*`;0&;BlJp%61iU&LbdDO5{0>h(B$5*l&xG|aV% zL$kaqC8?~vGL$wqj=##MAnF*#pWPAY}^@((Gh(y z-hB!ptVDfA9AH~eBfhBx<>Rgv)QwP?dA0@B07LJiYK)ubht2L*l#;y4J}Ofjp_Eo7 zM?N7xAUDdH(wk&*DRq6~+Usg2CHk842Tq?jB94$*<}vaA;b+M9lSHTba&)RLM`yMj z9idvEbw!jjkv`K-4N?2f<%Cv_CNy{{p%oVs8n6;dE(L1w6=iau2QhA#gV_P3Be~z) zIe=zK=n%picA}D<`_OLE`_}w~n1{^6`%nO20%iwMF|HaU@%!E&n#u^`8s-D5fN^*l z^5Ef9FwQ*mH2M@6aSeLPP$G3a0k>T7SfYcnuWVBy1W$i6xw%9iZZ~#C>nu=&>klFe zQ6sqjAgZxY%J_aPY8F3>P6XDIlP#nkr!sB{#wia2>=)A4|pITTFm;aAZ^kyG1f!eS8l2ky&*Cy>b(s?T|6Qh%QDBnbhGK aAyBrlfukT!W!8=TD!FT&8Cyy}&;18<`lQkT delta 2241 zcmY*aeN+_J6`yne%@4 zcYkx|z5U&p*KkT}IHk3wK}9T30u@JV4;m~*4_k_VbUZOXQIChy{|JLq^kTut)MNU~ z`YL^%@wGACxMWZ~5cKJ>&Op3)>~9h$lnH|1+4sqhtDMAx*!{u96sIn z2fy*EanHDAd}rK?4=Z}#V54_#vMyBy*~ncR;`b_{l9HPs4}8|Bj?V)gJx?&+FzSqa z{l5N@zDKXs^NcfEt26lee0n_Z$X|fVG(p#lea3UfR724(=w13cy-<6{8C>>HEv}vX zcL<)cq=CuSjDZ^X%Gx_{PdqS=MQGht$d#3S93pj8f+@=v9c*=$aQKM}x0G^t)`i!a zOj$YT!rKcu-0whI_a2(@>vu9idh$^`1kCt^?}7?z5XRES>CEhE_zx5Hej%S`JVX=W z`FQt(`I%5gQV^z5aS*Cdylw9Z!cBlfv~4(yMftpabU0Lb;S_abFq6iPffb@Qz)NJ5 z0537qJ~al`%d&jIeP*P>S^H-$p1TY={?x(k?w0yoIx&rz_T7oF4WzeRBBq0BcTIv8 z8M^FH0jxoI+wLrcx*#)^&7{=Af_T^;P{hyTWj9E*BG2wHlXx^ z-P!;uJ}MG?R77_xW>}|J@`{?+D438#;nA2)M_++_d61i?+kVVd#S}Nlwz#>fnCu24 zXzjPWMUvdW3by4cV&WrwtuYrxKYiW^A=!{#5KaKCiSzxu=&ril>W`VqFL~QnLs|P8 zFqKU%U&i??yQm31_QELgwL+RF$VH?0WyWD`pV8Y1ke}*MxLq*1jAH$=zS)zfo>5n; zK2qmkV1!a?X1ht488rpoi&xZHU-D@ zOu`3ptaH5RHtdT9{6*NU;D9WjbBT-^PD~8J3OmJvhXFe5(_So**leMf6hE#XA)4%a z_6N3$RkM+J2T$Vb_){DXx8Qwv6{;XzxFPh$!b7Onj}uv_ImJqB9IrGd^R`ROrrS#) zkCRDMUk98`bl5D~zu0B{*44)G*lbw-CO+v@_%lbNIU1+e^2AWHPo!N*n9oZjSf4v8 zuVuW-MIJ|#MzyP9ET~kIj3F*j=+HC3H8OqS&XT3S#zWBxzZSBWrC`@IQTk8_lGFz! zexd2{VK3@~Uq~q4q}Iha!-k7+03JCf2>9jyJC`VOrh~37!O1E|b&(wIbM0!A7CnFz zCznor$FPVaxI!N;$1qnx+he{uxq0--QY?3nhX!h~jH`rGkGV^?ct3H0Fpd7U1*h1D zufTjs(uAA*3nta#0>lYaU5mqLV=Zn(cErBL%K$6h^`uoZyV%~m0(WQ{o)@y9N5BpE z1oV*F356+jVx1U(p8t*I%|9V?7%XS=n@7>%!!X~AsX}pN*3{+-i7Gz8DQrpeR5}!Z z#rBN^$N*9NEwtK&cc2u+vYq238gmIsslgBB&L-wY3R8hvp97QTRAYv{Jr%f(PbWd8 zy(;`nia{tRsS~5Nk+!vCUi%T;Pue?}i*U|9djux|j3lWW zbCT44mDJhFL#0PqpfK5%pQXHRoDkccY47gFe=*UM1J~Vu-9B>+zX3L@Wr3v^&r&K| z=1Y-+G-?o8F7lJ5ncPw(MaB)K{RYpxvab6altriylFfuO*f{<(+n9J_4E1x=k(My?XTF& zPtZ+TnU?Ik=6l!oGJfrw4YqG6&Y_|KOsNvS@qXal;aw;ec(X+>-0oQAocsHaBk z^5jY$^#}D&Y8#}hEBPCKKn*Dm@D=5ZRL>47dzDqnBm$GC}DJgSU4nLFzd+gH1?1cPZH&%BY diff --git a/packages/adapters-library/src/adapters/integration.test.ts b/packages/adapters-library/src/adapters/integration.test.ts index 6897e9d91..f8152c416 100644 --- a/packages/adapters-library/src/adapters/integration.test.ts +++ b/packages/adapters-library/src/adapters/integration.test.ts @@ -67,6 +67,7 @@ import { testCases as lynexAlgebraTestCases } from './lynex/products/algebra/tes import { testCases as lynexClassicTestCases } from './lynex/products/classic/tests/testCases' import { testCases as makerSDaiTestCases } from './maker/products/s-dai/tests/testCases' import { testCases as mendiFinanceBorrowMarketTestCases } from './mendi-finance/products/borrow-market/tests/testCases' +import { testCases as mendiFinanceStakingTestCases } from './mendi-finance/products/staking/tests/testCases' import { testCases as mendiFinanceSupplyMarketTestCases } from './mendi-finance/products/supply-market/tests/testCases' import { testCases as morphoAaveV2OptimizerBorrowTestCases } from './morpho-aave-v2/products/optimizer-borrow/tests/testCases' import { testCases as morphoAaveV2OptimizerSupplyTestCases } from './morpho-aave-v2/products/optimizer-supply/tests/testCases' @@ -262,6 +263,7 @@ const allTestCases: Record> = { [Protocol.MendiFinance]: { ['borrow-market']: mendiFinanceBorrowMarketTestCases, + ['staking']: mendiFinanceStakingTestCases, ['supply-market']: mendiFinanceSupplyMarketTestCases, }, diff --git a/packages/adapters-library/src/adapters/mendi-finance/contracts/SMendi.ts b/packages/adapters-library/src/adapters/mendi-finance/contracts/SMendi.ts new file mode 100644 index 000000000..be133c3f5 --- /dev/null +++ b/packages/adapters-library/src/adapters/mendi-finance/contracts/SMendi.ts @@ -0,0 +1,970 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumberish, + BytesLike, + FunctionFragment, + Result, + Interface, + EventFragment, + AddressLike, + ContractRunner, + ContractMethod, + Listener, +} from "ethers"; +import type { + TypedContractEvent, + TypedDeferredTopicFilter, + TypedEventLog, + TypedLogDescription, + TypedListener, + TypedContractMethod, +} from "./common"; + +export interface SMendiInterface extends Interface { + getFunction( + nameOrSignature: + | "MANTISSA2" + | "_setClaimable" + | "_setWithdrawalPendingTime" + | "_whitelistToken" + | "allowance" + | "approve" + | "balanceOf" + | "burn" + | "claim" + | "claimAll" + | "claimable" + | "decimals" + | "decreaseAllowance" + | "getTokens" + | "increaseAllowance" + | "initialize" + | "mint" + | "name" + | "owner" + | "recipients" + | "renounceOwnership" + | "shareIndex" + | "shares" + | "symbol" + | "tokenExists" + | "tokens" + | "totalShares" + | "totalSupply" + | "transfer" + | "transferFrom" + | "transferOwnership" + | "underlying" + | "updateCredit" + | "updateShareIndex" + | "withdraw" + | "withdrawal" + | "withdrawalPendingTime" + ): FunctionFragment; + + getEvent( + nameOrSignatureOrTopic: + | "Approval" + | "Claim" + | "ClaimableUpdate" + | "EditRecipient" + | "Initialized" + | "OwnershipTransferred" + | "Transfer" + | "UpdateCredit" + | "UpdateShareIndex" + | "Withdraw" + ): EventFragment; + + encodeFunctionData(functionFragment: "MANTISSA2", values?: undefined): string; + encodeFunctionData( + functionFragment: "_setClaimable", + values: [AddressLike] + ): string; + encodeFunctionData( + functionFragment: "_setWithdrawalPendingTime", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "_whitelistToken", + values: [AddressLike] + ): string; + encodeFunctionData( + functionFragment: "allowance", + values: [AddressLike, AddressLike] + ): string; + encodeFunctionData( + functionFragment: "approve", + values: [AddressLike, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "balanceOf", + values: [AddressLike] + ): string; + encodeFunctionData(functionFragment: "burn", values: [BigNumberish]): string; + encodeFunctionData(functionFragment: "claim", values: [AddressLike]): string; + encodeFunctionData(functionFragment: "claimAll", values?: undefined): string; + encodeFunctionData(functionFragment: "claimable", values?: undefined): string; + encodeFunctionData(functionFragment: "decimals", values?: undefined): string; + encodeFunctionData( + functionFragment: "decreaseAllowance", + values: [AddressLike, BigNumberish] + ): string; + encodeFunctionData(functionFragment: "getTokens", values?: undefined): string; + encodeFunctionData( + functionFragment: "increaseAllowance", + values: [AddressLike, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "initialize", + values: [AddressLike, string, string, AddressLike] + ): string; + encodeFunctionData(functionFragment: "mint", values: [BigNumberish]): string; + encodeFunctionData(functionFragment: "name", values?: undefined): string; + encodeFunctionData(functionFragment: "owner", values?: undefined): string; + encodeFunctionData( + functionFragment: "recipients", + values: [AddressLike, AddressLike] + ): string; + encodeFunctionData( + functionFragment: "renounceOwnership", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "shareIndex", + values: [AddressLike] + ): string; + encodeFunctionData(functionFragment: "shares", values: [AddressLike]): string; + encodeFunctionData(functionFragment: "symbol", values?: undefined): string; + encodeFunctionData( + functionFragment: "tokenExists", + values: [AddressLike] + ): string; + encodeFunctionData( + functionFragment: "tokens", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "totalShares", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "totalSupply", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "transfer", + values: [AddressLike, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "transferFrom", + values: [AddressLike, AddressLike, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "transferOwnership", + values: [AddressLike] + ): string; + encodeFunctionData( + functionFragment: "underlying", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "updateCredit", + values: [AddressLike, AddressLike] + ): string; + encodeFunctionData( + functionFragment: "updateShareIndex", + values: [AddressLike] + ): string; + encodeFunctionData(functionFragment: "withdraw", values?: undefined): string; + encodeFunctionData( + functionFragment: "withdrawal", + values: [AddressLike] + ): string; + encodeFunctionData( + functionFragment: "withdrawalPendingTime", + values?: undefined + ): string; + + decodeFunctionResult(functionFragment: "MANTISSA2", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "_setClaimable", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "_setWithdrawalPendingTime", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "_whitelistToken", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "burn", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "claim", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "claimAll", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "claimable", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "decreaseAllowance", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "getTokens", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "increaseAllowance", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "mint", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "name", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "recipients", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "renounceOwnership", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "shareIndex", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "shares", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "tokenExists", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "tokens", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "totalShares", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "totalSupply", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "transferFrom", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "transferOwnership", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "underlying", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "updateCredit", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "updateShareIndex", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "withdrawal", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "withdrawalPendingTime", + data: BytesLike + ): Result; +} + +export namespace ApprovalEvent { + export type InputTuple = [ + owner: AddressLike, + spender: AddressLike, + value: BigNumberish + ]; + export type OutputTuple = [owner: string, spender: string, value: bigint]; + export interface OutputObject { + owner: string; + spender: string; + value: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace ClaimEvent { + export type InputTuple = [ + token: AddressLike, + account: AddressLike, + amount: BigNumberish + ]; + export type OutputTuple = [token: string, account: string, amount: bigint]; + export interface OutputObject { + token: string; + account: string; + amount: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace ClaimableUpdateEvent { + export type InputTuple = [ + oldClaimable: AddressLike, + newClaimable: AddressLike + ]; + export type OutputTuple = [oldClaimable: string, newClaimable: string]; + export interface OutputObject { + oldClaimable: string; + newClaimable: string; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace EditRecipientEvent { + export type InputTuple = [ + account: AddressLike, + shares: BigNumberish, + totalShares: BigNumberish + ]; + export type OutputTuple = [ + account: string, + shares: bigint, + totalShares: bigint + ]; + export interface OutputObject { + account: string; + shares: bigint; + totalShares: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace InitializedEvent { + export type InputTuple = [version: BigNumberish]; + export type OutputTuple = [version: bigint]; + export interface OutputObject { + version: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace OwnershipTransferredEvent { + export type InputTuple = [previousOwner: AddressLike, newOwner: AddressLike]; + export type OutputTuple = [previousOwner: string, newOwner: string]; + export interface OutputObject { + previousOwner: string; + newOwner: string; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace TransferEvent { + export type InputTuple = [ + from: AddressLike, + to: AddressLike, + value: BigNumberish + ]; + export type OutputTuple = [from: string, to: string, value: bigint]; + export interface OutputObject { + from: string; + to: string; + value: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace UpdateCreditEvent { + export type InputTuple = [ + token: AddressLike, + account: AddressLike, + lastShareIndex: BigNumberish, + credit: BigNumberish + ]; + export type OutputTuple = [ + token: string, + account: string, + lastShareIndex: bigint, + credit: bigint + ]; + export interface OutputObject { + token: string; + account: string; + lastShareIndex: bigint; + credit: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace UpdateShareIndexEvent { + export type InputTuple = [token: AddressLike, shareIndex: BigNumberish]; + export type OutputTuple = [token: string, shareIndex: bigint]; + export interface OutputObject { + token: string; + shareIndex: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace WithdrawEvent { + export type InputTuple = [user: AddressLike, amount: BigNumberish]; + export type OutputTuple = [user: string, amount: bigint]; + export interface OutputObject { + user: string; + amount: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export interface SMendi extends BaseContract { + connect(runner?: ContractRunner | null): SMendi; + waitForDeployment(): Promise; + + interface: SMendiInterface; + + queryFilter( + event: TCEvent, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>>; + queryFilter( + filter: TypedDeferredTopicFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>>; + + on( + event: TCEvent, + listener: TypedListener + ): Promise; + on( + filter: TypedDeferredTopicFilter, + listener: TypedListener + ): Promise; + + once( + event: TCEvent, + listener: TypedListener + ): Promise; + once( + filter: TypedDeferredTopicFilter, + listener: TypedListener + ): Promise; + + listeners( + event: TCEvent + ): Promise>>; + listeners(eventName?: string): Promise>; + removeAllListeners( + event?: TCEvent + ): Promise; + + MANTISSA2: TypedContractMethod<[], [bigint], "view">; + + _setClaimable: TypedContractMethod< + [newClaimable: AddressLike], + [void], + "nonpayable" + >; + + _setWithdrawalPendingTime: TypedContractMethod< + [withdrawalPendingTime_: BigNumberish], + [void], + "nonpayable" + >; + + _whitelistToken: TypedContractMethod< + [token_: AddressLike], + [void], + "nonpayable" + >; + + allowance: TypedContractMethod< + [owner: AddressLike, spender: AddressLike], + [bigint], + "view" + >; + + approve: TypedContractMethod< + [spender: AddressLike, amount: BigNumberish], + [boolean], + "nonpayable" + >; + + balanceOf: TypedContractMethod<[account: AddressLike], [bigint], "view">; + + burn: TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">; + + claim: TypedContractMethod<[token: AddressLike], [bigint], "nonpayable">; + + claimAll: TypedContractMethod<[], [bigint[]], "nonpayable">; + + claimable: TypedContractMethod<[], [string], "view">; + + decimals: TypedContractMethod<[], [bigint], "view">; + + decreaseAllowance: TypedContractMethod< + [spender: AddressLike, subtractedValue: BigNumberish], + [boolean], + "nonpayable" + >; + + getTokens: TypedContractMethod<[], [string[]], "view">; + + increaseAllowance: TypedContractMethod< + [spender: AddressLike, addedValue: BigNumberish], + [boolean], + "nonpayable" + >; + + initialize: TypedContractMethod< + [ + claimable_: AddressLike, + name: string, + symbol: string, + underlying_: AddressLike + ], + [void], + "nonpayable" + >; + + mint: TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">; + + name: TypedContractMethod<[], [string], "view">; + + owner: TypedContractMethod<[], [string], "view">; + + recipients: TypedContractMethod< + [arg0: AddressLike, arg1: AddressLike], + [[bigint, bigint] & { lastShareIndex: bigint; credit: bigint }], + "view" + >; + + renounceOwnership: TypedContractMethod<[], [void], "nonpayable">; + + shareIndex: TypedContractMethod<[arg0: AddressLike], [bigint], "view">; + + shares: TypedContractMethod<[arg0: AddressLike], [bigint], "view">; + + symbol: TypedContractMethod<[], [string], "view">; + + tokenExists: TypedContractMethod<[arg0: AddressLike], [boolean], "view">; + + tokens: TypedContractMethod<[arg0: BigNumberish], [string], "view">; + + totalShares: TypedContractMethod<[], [bigint], "view">; + + totalSupply: TypedContractMethod<[], [bigint], "view">; + + transfer: TypedContractMethod< + [to: AddressLike, amount: BigNumberish], + [boolean], + "nonpayable" + >; + + transferFrom: TypedContractMethod< + [from: AddressLike, to: AddressLike, amount: BigNumberish], + [boolean], + "nonpayable" + >; + + transferOwnership: TypedContractMethod< + [newOwner: AddressLike], + [void], + "nonpayable" + >; + + underlying: TypedContractMethod<[], [string], "view">; + + updateCredit: TypedContractMethod< + [token: AddressLike, account: AddressLike], + [bigint], + "nonpayable" + >; + + updateShareIndex: TypedContractMethod< + [token: AddressLike], + [bigint], + "nonpayable" + >; + + withdraw: TypedContractMethod<[], [void], "nonpayable">; + + withdrawal: TypedContractMethod< + [arg0: AddressLike], + [[bigint, bigint] & { amount: bigint; releaseTime: bigint }], + "view" + >; + + withdrawalPendingTime: TypedContractMethod<[], [bigint], "view">; + + getFunction( + key: string | FunctionFragment + ): T; + + getFunction( + nameOrSignature: "MANTISSA2" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "_setClaimable" + ): TypedContractMethod<[newClaimable: AddressLike], [void], "nonpayable">; + getFunction( + nameOrSignature: "_setWithdrawalPendingTime" + ): TypedContractMethod< + [withdrawalPendingTime_: BigNumberish], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "_whitelistToken" + ): TypedContractMethod<[token_: AddressLike], [void], "nonpayable">; + getFunction( + nameOrSignature: "allowance" + ): TypedContractMethod< + [owner: AddressLike, spender: AddressLike], + [bigint], + "view" + >; + getFunction( + nameOrSignature: "approve" + ): TypedContractMethod< + [spender: AddressLike, amount: BigNumberish], + [boolean], + "nonpayable" + >; + getFunction( + nameOrSignature: "balanceOf" + ): TypedContractMethod<[account: AddressLike], [bigint], "view">; + getFunction( + nameOrSignature: "burn" + ): TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">; + getFunction( + nameOrSignature: "claim" + ): TypedContractMethod<[token: AddressLike], [bigint], "nonpayable">; + getFunction( + nameOrSignature: "claimAll" + ): TypedContractMethod<[], [bigint[]], "nonpayable">; + getFunction( + nameOrSignature: "claimable" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "decimals" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "decreaseAllowance" + ): TypedContractMethod< + [spender: AddressLike, subtractedValue: BigNumberish], + [boolean], + "nonpayable" + >; + getFunction( + nameOrSignature: "getTokens" + ): TypedContractMethod<[], [string[]], "view">; + getFunction( + nameOrSignature: "increaseAllowance" + ): TypedContractMethod< + [spender: AddressLike, addedValue: BigNumberish], + [boolean], + "nonpayable" + >; + getFunction( + nameOrSignature: "initialize" + ): TypedContractMethod< + [ + claimable_: AddressLike, + name: string, + symbol: string, + underlying_: AddressLike + ], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "mint" + ): TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">; + getFunction( + nameOrSignature: "name" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "owner" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "recipients" + ): TypedContractMethod< + [arg0: AddressLike, arg1: AddressLike], + [[bigint, bigint] & { lastShareIndex: bigint; credit: bigint }], + "view" + >; + getFunction( + nameOrSignature: "renounceOwnership" + ): TypedContractMethod<[], [void], "nonpayable">; + getFunction( + nameOrSignature: "shareIndex" + ): TypedContractMethod<[arg0: AddressLike], [bigint], "view">; + getFunction( + nameOrSignature: "shares" + ): TypedContractMethod<[arg0: AddressLike], [bigint], "view">; + getFunction( + nameOrSignature: "symbol" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "tokenExists" + ): TypedContractMethod<[arg0: AddressLike], [boolean], "view">; + getFunction( + nameOrSignature: "tokens" + ): TypedContractMethod<[arg0: BigNumberish], [string], "view">; + getFunction( + nameOrSignature: "totalShares" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "totalSupply" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "transfer" + ): TypedContractMethod< + [to: AddressLike, amount: BigNumberish], + [boolean], + "nonpayable" + >; + getFunction( + nameOrSignature: "transferFrom" + ): TypedContractMethod< + [from: AddressLike, to: AddressLike, amount: BigNumberish], + [boolean], + "nonpayable" + >; + getFunction( + nameOrSignature: "transferOwnership" + ): TypedContractMethod<[newOwner: AddressLike], [void], "nonpayable">; + getFunction( + nameOrSignature: "underlying" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "updateCredit" + ): TypedContractMethod< + [token: AddressLike, account: AddressLike], + [bigint], + "nonpayable" + >; + getFunction( + nameOrSignature: "updateShareIndex" + ): TypedContractMethod<[token: AddressLike], [bigint], "nonpayable">; + getFunction( + nameOrSignature: "withdraw" + ): TypedContractMethod<[], [void], "nonpayable">; + getFunction( + nameOrSignature: "withdrawal" + ): TypedContractMethod< + [arg0: AddressLike], + [[bigint, bigint] & { amount: bigint; releaseTime: bigint }], + "view" + >; + getFunction( + nameOrSignature: "withdrawalPendingTime" + ): TypedContractMethod<[], [bigint], "view">; + + getEvent( + key: "Approval" + ): TypedContractEvent< + ApprovalEvent.InputTuple, + ApprovalEvent.OutputTuple, + ApprovalEvent.OutputObject + >; + getEvent( + key: "Claim" + ): TypedContractEvent< + ClaimEvent.InputTuple, + ClaimEvent.OutputTuple, + ClaimEvent.OutputObject + >; + getEvent( + key: "ClaimableUpdate" + ): TypedContractEvent< + ClaimableUpdateEvent.InputTuple, + ClaimableUpdateEvent.OutputTuple, + ClaimableUpdateEvent.OutputObject + >; + getEvent( + key: "EditRecipient" + ): TypedContractEvent< + EditRecipientEvent.InputTuple, + EditRecipientEvent.OutputTuple, + EditRecipientEvent.OutputObject + >; + getEvent( + key: "Initialized" + ): TypedContractEvent< + InitializedEvent.InputTuple, + InitializedEvent.OutputTuple, + InitializedEvent.OutputObject + >; + getEvent( + key: "OwnershipTransferred" + ): TypedContractEvent< + OwnershipTransferredEvent.InputTuple, + OwnershipTransferredEvent.OutputTuple, + OwnershipTransferredEvent.OutputObject + >; + getEvent( + key: "Transfer" + ): TypedContractEvent< + TransferEvent.InputTuple, + TransferEvent.OutputTuple, + TransferEvent.OutputObject + >; + getEvent( + key: "UpdateCredit" + ): TypedContractEvent< + UpdateCreditEvent.InputTuple, + UpdateCreditEvent.OutputTuple, + UpdateCreditEvent.OutputObject + >; + getEvent( + key: "UpdateShareIndex" + ): TypedContractEvent< + UpdateShareIndexEvent.InputTuple, + UpdateShareIndexEvent.OutputTuple, + UpdateShareIndexEvent.OutputObject + >; + getEvent( + key: "Withdraw" + ): TypedContractEvent< + WithdrawEvent.InputTuple, + WithdrawEvent.OutputTuple, + WithdrawEvent.OutputObject + >; + + filters: { + "Approval(address,address,uint256)": TypedContractEvent< + ApprovalEvent.InputTuple, + ApprovalEvent.OutputTuple, + ApprovalEvent.OutputObject + >; + Approval: TypedContractEvent< + ApprovalEvent.InputTuple, + ApprovalEvent.OutputTuple, + ApprovalEvent.OutputObject + >; + + "Claim(address,address,uint256)": TypedContractEvent< + ClaimEvent.InputTuple, + ClaimEvent.OutputTuple, + ClaimEvent.OutputObject + >; + Claim: TypedContractEvent< + ClaimEvent.InputTuple, + ClaimEvent.OutputTuple, + ClaimEvent.OutputObject + >; + + "ClaimableUpdate(address,address)": TypedContractEvent< + ClaimableUpdateEvent.InputTuple, + ClaimableUpdateEvent.OutputTuple, + ClaimableUpdateEvent.OutputObject + >; + ClaimableUpdate: TypedContractEvent< + ClaimableUpdateEvent.InputTuple, + ClaimableUpdateEvent.OutputTuple, + ClaimableUpdateEvent.OutputObject + >; + + "EditRecipient(address,uint256,uint256)": TypedContractEvent< + EditRecipientEvent.InputTuple, + EditRecipientEvent.OutputTuple, + EditRecipientEvent.OutputObject + >; + EditRecipient: TypedContractEvent< + EditRecipientEvent.InputTuple, + EditRecipientEvent.OutputTuple, + EditRecipientEvent.OutputObject + >; + + "Initialized(uint8)": TypedContractEvent< + InitializedEvent.InputTuple, + InitializedEvent.OutputTuple, + InitializedEvent.OutputObject + >; + Initialized: TypedContractEvent< + InitializedEvent.InputTuple, + InitializedEvent.OutputTuple, + InitializedEvent.OutputObject + >; + + "OwnershipTransferred(address,address)": TypedContractEvent< + OwnershipTransferredEvent.InputTuple, + OwnershipTransferredEvent.OutputTuple, + OwnershipTransferredEvent.OutputObject + >; + OwnershipTransferred: TypedContractEvent< + OwnershipTransferredEvent.InputTuple, + OwnershipTransferredEvent.OutputTuple, + OwnershipTransferredEvent.OutputObject + >; + + "Transfer(address,address,uint256)": TypedContractEvent< + TransferEvent.InputTuple, + TransferEvent.OutputTuple, + TransferEvent.OutputObject + >; + Transfer: TypedContractEvent< + TransferEvent.InputTuple, + TransferEvent.OutputTuple, + TransferEvent.OutputObject + >; + + "UpdateCredit(address,address,uint256,uint256)": TypedContractEvent< + UpdateCreditEvent.InputTuple, + UpdateCreditEvent.OutputTuple, + UpdateCreditEvent.OutputObject + >; + UpdateCredit: TypedContractEvent< + UpdateCreditEvent.InputTuple, + UpdateCreditEvent.OutputTuple, + UpdateCreditEvent.OutputObject + >; + + "UpdateShareIndex(address,uint256)": TypedContractEvent< + UpdateShareIndexEvent.InputTuple, + UpdateShareIndexEvent.OutputTuple, + UpdateShareIndexEvent.OutputObject + >; + UpdateShareIndex: TypedContractEvent< + UpdateShareIndexEvent.InputTuple, + UpdateShareIndexEvent.OutputTuple, + UpdateShareIndexEvent.OutputObject + >; + + "Withdraw(address,uint256)": TypedContractEvent< + WithdrawEvent.InputTuple, + WithdrawEvent.OutputTuple, + WithdrawEvent.OutputObject + >; + Withdraw: TypedContractEvent< + WithdrawEvent.InputTuple, + WithdrawEvent.OutputTuple, + WithdrawEvent.OutputObject + >; + }; +} diff --git a/packages/adapters-library/src/adapters/mendi-finance/contracts/abis/sMendi.json b/packages/adapters-library/src/adapters/mendi-finance/contracts/abis/sMendi.json new file mode 100644 index 000000000..3fe073e20 --- /dev/null +++ b/packages/adapters-library/src/adapters/mendi-finance/contracts/abis/sMendi.json @@ -0,0 +1 @@ +[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Claim","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldClaimable","type":"address"},{"indexed":false,"internalType":"address","name":"newClaimable","type":"address"}],"name":"ClaimableUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"totalShares","type":"uint256"}],"name":"EditRecipient","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"lastShareIndex","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"credit","type":"uint256"}],"name":"UpdateCredit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"shareIndex","type":"uint256"}],"name":"UpdateShareIndex","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"MANTISSA2","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newClaimable","type":"address"}],"name":"_setClaimable","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"withdrawalPendingTime_","type":"uint256"}],"name":"_setWithdrawalPendingTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token_","type":"address"}],"name":"_whitelistToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"claim","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimAll","outputs":[{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimable","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getTokens","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"claimable_","type":"address"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"address","name":"underlying_","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"recipients","outputs":[{"internalType":"uint256","name":"lastShareIndex","type":"uint256"},{"internalType":"uint256","name":"credit","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"shareIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"shares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"tokenExists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"tokens","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"underlying","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"updateCredit","outputs":[{"internalType":"uint256","name":"credit","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"updateShareIndex","outputs":[{"internalType":"uint256","name":"_shareIndex","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"withdrawal","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"releaseTime","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawalPendingTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}] \ No newline at end of file diff --git a/packages/adapters-library/src/adapters/mendi-finance/contracts/factories/SMendi__factory.ts b/packages/adapters-library/src/adapters/mendi-finance/contracts/factories/SMendi__factory.ts new file mode 100644 index 000000000..72d410de2 --- /dev/null +++ b/packages/adapters-library/src/adapters/mendi-finance/contracts/factories/SMendi__factory.ts @@ -0,0 +1,874 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Interface, type ContractRunner } from "ethers"; +import type { SMendi, SMendiInterface } from "../SMendi"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "owner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "spender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "Approval", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "account", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "Claim", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "oldClaimable", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "newClaimable", + type: "address", + }, + ], + name: "ClaimableUpdate", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "account", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "shares", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "totalShares", + type: "uint256", + }, + ], + name: "EditRecipient", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint8", + name: "version", + type: "uint8", + }, + ], + name: "Initialized", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "previousOwner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "OwnershipTransferred", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "from", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "Transfer", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "account", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "lastShareIndex", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "credit", + type: "uint256", + }, + ], + name: "UpdateCredit", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "shareIndex", + type: "uint256", + }, + ], + name: "UpdateShareIndex", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "user", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "Withdraw", + type: "event", + }, + { + inputs: [], + name: "MANTISSA2", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newClaimable", + type: "address", + }, + ], + name: "_setClaimable", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "withdrawalPendingTime_", + type: "uint256", + }, + ], + name: "_setWithdrawalPendingTime", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token_", + type: "address", + }, + ], + name: "_whitelistToken", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "owner", + type: "address", + }, + { + internalType: "address", + name: "spender", + type: "address", + }, + ], + name: "allowance", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "spender", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "approve", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "balanceOf", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "burn", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + ], + name: "claim", + outputs: [ + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "claimAll", + outputs: [ + { + internalType: "uint256[]", + name: "amounts", + type: "uint256[]", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "claimable", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "decimals", + outputs: [ + { + internalType: "uint8", + name: "", + type: "uint8", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "spender", + type: "address", + }, + { + internalType: "uint256", + name: "subtractedValue", + type: "uint256", + }, + ], + name: "decreaseAllowance", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "getTokens", + outputs: [ + { + internalType: "address[]", + name: "", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "spender", + type: "address", + }, + { + internalType: "uint256", + name: "addedValue", + type: "uint256", + }, + ], + name: "increaseAllowance", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "claimable_", + type: "address", + }, + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "symbol", + type: "string", + }, + { + internalType: "address", + name: "underlying_", + type: "address", + }, + ], + name: "initialize", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "mint", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "name", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "owner", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + { + internalType: "address", + name: "", + type: "address", + }, + ], + name: "recipients", + outputs: [ + { + internalType: "uint256", + name: "lastShareIndex", + type: "uint256", + }, + { + internalType: "uint256", + name: "credit", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "renounceOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + name: "shareIndex", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + name: "shares", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "symbol", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + name: "tokenExists", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + name: "tokens", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "totalShares", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "totalSupply", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "transfer", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "from", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "transferFrom", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "transferOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "underlying", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "updateCredit", + outputs: [ + { + internalType: "uint256", + name: "credit", + type: "uint256", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + ], + name: "updateShareIndex", + outputs: [ + { + internalType: "uint256", + name: "_shareIndex", + type: "uint256", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "withdraw", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + name: "withdrawal", + outputs: [ + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "uint256", + name: "releaseTime", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "withdrawalPendingTime", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, +] as const; + +export class SMendi__factory { + static readonly abi = _abi; + static createInterface(): SMendiInterface { + return new Interface(_abi) as SMendiInterface; + } + static connect(address: string, runner?: ContractRunner | null): SMendi { + return new Contract(address, _abi, runner) as unknown as SMendi; + } +} diff --git a/packages/adapters-library/src/adapters/mendi-finance/contracts/factories/index.ts b/packages/adapters-library/src/adapters/mendi-finance/contracts/factories/index.ts index c1f8276dd..2d7025b67 100644 --- a/packages/adapters-library/src/adapters/mendi-finance/contracts/factories/index.ts +++ b/packages/adapters-library/src/adapters/mendi-finance/contracts/factories/index.ts @@ -5,6 +5,7 @@ export { Cerc20__factory } from "./Cerc20__factory"; export { Comptroller__factory } from "./Comptroller__factory"; export { Converter__factory } from "./Converter__factory"; export { Oracle__factory } from "./Oracle__factory"; +export { SMendi__factory } from "./SMendi__factory"; export { Speed__factory } from "./Speed__factory"; export { Token__factory } from "./Token__factory"; export { Velocore__factory } from "./Velocore__factory"; diff --git a/packages/adapters-library/src/adapters/mendi-finance/contracts/index.ts b/packages/adapters-library/src/adapters/mendi-finance/contracts/index.ts index c66c19f24..09381d214 100644 --- a/packages/adapters-library/src/adapters/mendi-finance/contracts/index.ts +++ b/packages/adapters-library/src/adapters/mendi-finance/contracts/index.ts @@ -5,6 +5,7 @@ export type { Cerc20 } from "./Cerc20"; export type { Comptroller } from "./Comptroller"; export type { Converter } from "./Converter"; export type { Oracle } from "./Oracle"; +export type { SMendi } from "./SMendi"; export type { Speed } from "./Speed"; export type { Token } from "./Token"; export type { Velocore } from "./Velocore"; @@ -13,6 +14,7 @@ export { Cerc20__factory } from "./factories/Cerc20__factory"; export { Comptroller__factory } from "./factories/Comptroller__factory"; export { Converter__factory } from "./factories/Converter__factory"; export { Oracle__factory } from "./factories/Oracle__factory"; +export { SMendi__factory } from "./factories/SMendi__factory"; export { Speed__factory } from "./factories/Speed__factory"; export { Token__factory } from "./factories/Token__factory"; export { Velocore__factory } from "./factories/Velocore__factory"; diff --git a/packages/adapters-library/src/adapters/mendi-finance/products/staking/mendiFinanceStakingAdapter.ts b/packages/adapters-library/src/adapters/mendi-finance/products/staking/mendiFinanceStakingAdapter.ts new file mode 100644 index 000000000..3fae0792e --- /dev/null +++ b/packages/adapters-library/src/adapters/mendi-finance/products/staking/mendiFinanceStakingAdapter.ts @@ -0,0 +1,209 @@ +import { getAddress } from 'ethers' +import { AdaptersController } from '../../../../core/adaptersController' +import { Chain } from '../../../../core/constants/chains' +import { CacheToDb } from '../../../../core/decorators/cacheToDb' +import { NotImplementedError } from '../../../../core/errors/errors' +import { CustomJsonRpcProvider } from '../../../../core/provider/CustomJsonRpcProvider' +import { filterMapAsync } from '../../../../core/utils/filters' +import { logger } from '../../../../core/utils/logger' +import { Helpers } from '../../../../scripts/helpers' +import { + IProtocolAdapter, + ProtocolToken, +} from '../../../../types/IProtocolAdapter' +import { + AssetType, + GetEventsInput, + GetPositionsInput, + GetRewardPositionsInput, + GetTotalValueLockedInput, + MovementsByBlock, + MovementsByBlockReward, + PositionType, + ProtocolAdapterParams, + ProtocolDetails, + ProtocolPosition, + ProtocolTokenTvl, + TokenType, + Underlying, + UnderlyingReward, + UnwrapExchangeRate, + UnwrapInput, +} from '../../../../types/adapter' +import { Erc20Metadata } from '../../../../types/erc20Metadata' +import { Protocol } from '../../../protocols' +import { SMendi__factory } from '../../contracts' + +type AdditionalMetadata = { rewardTokens: Erc20Metadata[] } + +const S_MENDI_ADDRESS = '0x150b1e51738cdf0ccfe472594c62d7d6074921ca' +export class MendiFinanceStakingAdapter implements IProtocolAdapter { + productId = 'staking' + protocolId: Protocol + chainId: Chain + helpers: Helpers + + adapterSettings = { + enablePositionDetectionByProtocolTokenTransfer: false, + includeInUnwrap: true, + } + + private provider: CustomJsonRpcProvider + + adaptersController: AdaptersController + + constructor({ + provider, + chainId, + protocolId, + adaptersController, + helpers, + }: ProtocolAdapterParams) { + this.provider = provider + this.chainId = chainId + this.protocolId = protocolId + this.adaptersController = adaptersController + this.helpers = helpers + } + + /** + * Update me. + * Add your protocol details + */ + getProtocolDetails(): ProtocolDetails { + return { + protocolId: this.protocolId, + name: 'MendiFinance', + description: 'MendiFinance defi adapter', + siteUrl: 'https:', + iconUrl: 'https://', + positionType: PositionType.Supply, + chainId: this.chainId, + productId: this.productId, + } + } + + @CacheToDb + async getProtocolTokens(): Promise[]> { + const protocolToken = await this.helpers.getTokenMetadata(S_MENDI_ADDRESS) + + const underlyingToken = await this.helpers.getTokenMetadata( + '0x43E8809ea748EFf3204ee01F08872F063e44065f', + ) + + const sMendiContract = SMendi__factory.connect( + S_MENDI_ADDRESS, + this.provider, + ) + + const rewardTokens = await sMendiContract.getTokens() + + return [ + { + ...protocolToken, + underlyingTokens: [underlyingToken], + rewardTokens: await Promise.all( + rewardTokens.map((token: string) => { + return this.helpers.getTokenMetadata(token) + }), + ), + }, + ] + } + + private async getProtocolTokenByAddress(protocolTokenAddress: string) { + return this.helpers.getProtocolTokenByAddress({ + protocolTokens: await this.getProtocolTokens(), + protocolTokenAddress, + }) + } + + async getPositions(input: GetPositionsInput): Promise { + return this.helpers.getBalanceOfTokens({ + ...input, + protocolTokens: await this.getProtocolTokens(), + }) + } + + async getWithdrawals({ + protocolTokenAddress, + fromBlock, + toBlock, + userAddress, + }: GetEventsInput): Promise { + throw new NotImplementedError() + } + + async getDeposits({ + protocolTokenAddress, + fromBlock, + toBlock, + userAddress, + }: GetEventsInput): Promise { + throw new NotImplementedError() + } + + async getTotalValueLocked({ + protocolTokenAddresses, + blockNumber, + }: GetTotalValueLockedInput): Promise { + const protocolTokens = await this.getProtocolTokens() + + return await this.helpers.tvl({ + protocolTokens, + filterProtocolTokenAddresses: protocolTokenAddresses, + blockNumber, + }) + } + + async unwrap({ + protocolTokenAddress, + tokenId, + blockNumber, + }: UnwrapInput): Promise { + return this.helpers.unwrapOneToOne({ + protocolToken: await this.getProtocolTokenByAddress(protocolTokenAddress), + underlyingTokens: ( + await this.getProtocolTokenByAddress(protocolTokenAddress) + ).underlyingTokens, + }) + } + + async getRewardPositions({ + userAddress, + protocolTokenAddress, + blockNumber, + tokenId, + }: GetRewardPositionsInput): Promise { + const sMendiContract = SMendi__factory.connect( + S_MENDI_ADDRESS, + this.provider, + ) + + const protocolTokens = await this.getProtocolTokens() + + if (!protocolTokens) { + return [] + } + + const rewardTokens = protocolTokens[0]!.rewardTokens + + return filterMapAsync(rewardTokens, async (rewardToken) => { + const balanceRaw = await sMendiContract.claim.staticCall( + rewardToken.address, + { from: userAddress }, + ) + + if (balanceRaw === 0n) { + return undefined + } + + return { + balanceRaw, + ...rewardToken, + + type: TokenType.UnderlyingClaimable, + } + }) + } +} diff --git a/packages/adapters-library/src/adapters/mendi-finance/products/staking/tests/snapshots/linea.positions.staking.json b/packages/adapters-library/src/adapters/mendi-finance/products/staking/tests/snapshots/linea.positions.staking.json new file mode 100644 index 000000000..dcea1db01 --- /dev/null +++ b/packages/adapters-library/src/adapters/mendi-finance/products/staking/tests/snapshots/linea.positions.staking.json @@ -0,0 +1,115 @@ +{ + "blockNumber": 12802108, + "latency": "Latency: 1.462 seconds", + "aggregatedValues": [], + "snapshot": [ + { + "protocolId": "mendi-finance", + "name": "MendiFinance", + "description": "MendiFinance defi adapter", + "siteUrl": "https:", + "iconUrl": "https://", + "positionType": "supply", + "chainId": 59144, + "productId": "staking", + "chainName": "linea", + "success": true, + "tokens": [ + { + "address": "0x150b1e51738CdF0cCfe472594C62d7D6074921CA", + "name": "Staked Mendi", + "symbol": "sMendi", + "decimals": 18, + "balanceRaw": "29191573601067797911n", + "type": "protocol", + "tokens": [ + { + "balanceRaw": "331422448426821234n", + "address": "0x43E8809ea748EFf3204ee01F08872F063e44065f", + "name": "Mendi Finance", + "symbol": "MENDI", + "decimals": 18, + "type": "underlying-claimable", + "balance": 0.3314224484268212, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/linea/assets/0x43E8809ea748EFf3204ee01F08872F063e44065f/logo.png" + }, + { + "balanceRaw": "600839417931799785n", + "address": "0x63349BA5E1F71252eCD56E8F950D1A518B400b60", + "name": "Option LYNX Token", + "symbol": "oLYNX", + "decimals": 18, + "type": "underlying-claimable", + "balance": 0.6008394179317997, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/linea/assets/0x63349BA5E1F71252eCD56E8F950D1A518B400b60/logo.png" + }, + { + "address": "0x43E8809ea748EFf3204ee01F08872F063e44065f", + "name": "Mendi Finance", + "symbol": "MENDI", + "decimals": 18, + "type": "underlying", + "balanceRaw": "29191573601067797911n", + "balance": 29.191573601067798, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/linea/assets/0x43E8809ea748EFf3204ee01F08872F063e44065f/logo.png" + } + ], + "balance": 29.191573601067798 + } + ] + } + ], + "rpcResponses": { + "7b0d0d7f8125ddb4eea83120aa14caa0": { + "result": "0x00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000006734d656e64690000000000000000000000000000000000000000000000000000" + }, + "098abfdf638a17bea4679a2e5bdd5f87": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000012" + }, + "51bbbbbda6d72c046b7f855b80f2169f": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000c5374616b6564204d656e64690000000000000000000000000000000000000000" + }, + "04c1ac48f0a31770959a8d4fcdbe4588": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000d4d656e64692046696e616e636500000000000000000000000000000000000000" + }, + "77615b9b78b9d06aea937c2355010e65": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000012" + }, + "a4cb3b010ac0d1aa742ab0ddc8510334": { + "result": "0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000054d454e4449000000000000000000000000000000000000000000000000000000" + }, + "7850e673db73a74f0553797765b61703": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000300000000000000000000000043e8809ea748eff3204ee01f08872f063e44065f000000000000000000000000cc22f6aa610d1b2a0e89ef228079cb3e1831b1d100000000000000000000000063349ba5e1f71252ecd56e8f950d1a518b400b60" + }, + "7fd07b9a056355637b1aa4d7e5b7fb98": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000012" + }, + "e46e86841c5dbc7f23f5459952bd68c1": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000e4c696e65612056656c6f636f7265000000000000000000000000000000000000" + }, + "26818c1b104ac07ec543a31bf8fff979": { + "result": "0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000056f4c594e58000000000000000000000000000000000000000000000000000000" + }, + "0629325d05b23d6e6cd32ed06f08447c": { + "result": "0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000034c56430000000000000000000000000000000000000000000000000000000000" + }, + "8044f922b95f63db17a8f18f1e0e1e34": { + "result": "0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000114f7074696f6e204c594e5820546f6b656e000000000000000000000000000000" + }, + "44c646ac5fdc0db5d0545b1c468f1518": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000012" + }, + "aebb53f9ddbc6fa33eb439760d1fb34f": { + "result": "0x000000000000000000000000000000000000000000000001951d4d86ce510d97" + }, + "329c4179a3fbd764b3fef91625b9c9d3": { + "result": "0x000000000000000000000000000000000000000000000000049972f5fd122672" + }, + "72ace0e3ec958d226e0a5247f2938f6c": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000000" + }, + "919b04c6e902fec1c3fc4e7d339b07aa": { + "result": "0x00000000000000000000000000000000000000000000000008569c4468e09ce9" + } + } +} diff --git a/packages/adapters-library/src/adapters/mendi-finance/products/staking/tests/testCases.ts b/packages/adapters-library/src/adapters/mendi-finance/products/staking/tests/testCases.ts new file mode 100644 index 000000000..75090311d --- /dev/null +++ b/packages/adapters-library/src/adapters/mendi-finance/products/staking/tests/testCases.ts @@ -0,0 +1,26 @@ +import { Chain } from '../../../../../core/constants/chains' +import { TimePeriod } from '../../../../../core/constants/timePeriod' +import type { TestCase } from '../../../../../types/testCase' + +export const testCases: TestCase[] = [ + { + chainId: Chain.Linea, + method: 'positions', + key: 'staking', + + input: { + userAddress: '0x3130D2b8cbf0798bb1cBf2a4F527dBaE953FF27f', + filterProtocolTokens: ['0x150b1e51738CdF0cCfe472594C62d7D6074921CA'], + }, + + blockNumber: 12802108, + }, + // { + // chainId: Chain.Ethereum, + // method: 'profits', + // input: { + // userAddress: '0xCEadFdCCd0E8E370D985c49Ed3117b2572243A4a', + // timePeriod: TimePeriod.oneDay, + // }, + // }, +] diff --git a/packages/adapters-library/src/adapters/supportedProtocols.ts b/packages/adapters-library/src/adapters/supportedProtocols.ts index d63559252..46afabfa6 100644 --- a/packages/adapters-library/src/adapters/supportedProtocols.ts +++ b/packages/adapters-library/src/adapters/supportedProtocols.ts @@ -151,6 +151,8 @@ import { DineroApxEthAdapter } from './dinero/products/apx-eth/dineroApxEthAdapt import { BalancerV2FarmingAdapter } from './balancer-v2/products/farming/balancerV2FarmingAdapter' +import { MendiFinanceStakingAdapter } from './mendi-finance/products/staking/mendiFinanceStakingAdapter' + export const supportedProtocols: Record< Protocol, Partial< @@ -422,6 +424,7 @@ export const supportedProtocols: Record< [Chain.Linea]: [ MendiFinanceSupplyMarketAdapter, MendiFinanceBorrowMarketAdapter, + MendiFinanceStakingAdapter, ], }, From 86e0f6b50320a31f52ea83d3034f3faace603fb3 Mon Sep 17 00:00:00 2001 From: Bernardo Garces Chapero Date: Thu, 5 Dec 2024 11:19:52 +0000 Subject: [PATCH 2/4] add lido and EtherFi markets (#386) --- arb.db | Bin 2093056 -> 2105344 bytes avax.db | Bin 266240 -> 270336 bytes base.db | Bin 14807040 -> 14807040 bytes ethereum.db | Bin 8953856 -> 8953856 bytes matic.db | Bin 8355840 -> 8355840 bytes op.db | Bin 716800 -> 720896 bytes .../aave-v2/common/aaveBasePoolAdapter.ts | 201 +++++++++++++----- .../products/rewards/aaveV2RewardsAdapter.ts | 3 +- .../ethereum.positions.lido-market.json | 51 +++++ .../products/a-token/tests/testCases.ts | 12 ++ .../products/rewards/aaveV3RewardsAdapter.ts | 110 +++------- .../ethereum.positions.lido-market.json | 146 +++++++++++++ .../products/rewards/tests/testCases.ts | 13 +- .../products/os-eth/stakeWiseOsEthAdapter.ts | 19 +- .../tests/snapshots/ethereum.deposits.json | 4 +- .../tests/snapshots/ethereum.positions.json | 2 +- .../tests/snapshots/ethereum.prices.json | 2 +- .../tests/snapshots/ethereum.profits.json | 2 +- .../os-eth/tests/snapshots/ethereum.tvl.json | 2 +- .../tests/snapshots/ethereum.withdrawals.json | 4 +- 20 files changed, 424 insertions(+), 147 deletions(-) create mode 100644 packages/adapters-library/src/adapters/aave-v3/products/a-token/tests/snapshots/ethereum.positions.lido-market.json create mode 100644 packages/adapters-library/src/adapters/aave-v3/products/rewards/tests/snapshots/ethereum.positions.lido-market.json diff --git a/arb.db b/arb.db index 83f63f9a3c509ae18a415eac7f654e64d3ea96e6..769d17bb852102f893ff58f180090c29adc07cec 100644 GIT binary patch delta 11999 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 Kfl!4x-+u$z)dUp) delta 7312 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 diff --git a/avax.db b/avax.db index d44f109f3fd2b11ed7666f49737713ac70c88196..00d8562860cc5a285ca9a6032a2d6d9e5d915aab 100644 GIT binary patch delta 9549 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 delta 3313 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
Eq*xW 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 X9$kL}=A$uA;UmxbYs}k4^@jfi{;3o= diff --git a/matic.db b/matic.db index d2186bf7e99de55b06dfb999c8c5fdabc84206e4..8d6b964fe7db8b8d77da3feb6a48c159dc387e09 100644 GIT binary patch delta 25496 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 m%8Z^M2L8mi~YE3E*D< delta 20453 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 diff --git a/op.db b/op.db index 9226d31babdd0cc6c3bb44f86cc7588c23631c72..077660c5e7f0f79f9acf0abc73bacb73c286480f 100644 GIT binary patch delta 4571 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 HV7KRw8~-KZ delta 4031 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 diff --git a/packages/adapters-library/src/adapters/aave-v2/common/aaveBasePoolAdapter.ts b/packages/adapters-library/src/adapters/aave-v2/common/aaveBasePoolAdapter.ts index 8759289d6..d88609134 100644 --- a/packages/adapters-library/src/adapters/aave-v2/common/aaveBasePoolAdapter.ts +++ b/packages/adapters-library/src/adapters/aave-v2/common/aaveBasePoolAdapter.ts @@ -3,7 +3,7 @@ import { AdaptersController } from '../../../core/adaptersController' import { ZERO_ADDRESS } from '../../../core/constants/ZERO_ADDRESS' import { Chain } from '../../../core/constants/chains' import { CustomJsonRpcProvider } from '../../../core/provider/CustomJsonRpcProvider' -import { getTokenMetadata } from '../../../core/utils/getTokenMetadata' +import { filterMapAsync } from '../../../core/utils/filters' import { Helpers } from '../../../scripts/helpers' import { IProtocolAdapter, @@ -30,21 +30,111 @@ import { } from '../contracts' export const protocolDataProviderContractAddresses: Partial< - Record>> + Record< + Protocol, + Partial< + Record< + Chain, + { + marketLabel?: string + protocolDataProvider: string + }[] + > + > + > > = { [Protocol.AaveV2]: { - [Chain.Ethereum]: getAddress('0x057835Ad21a177dbdd3090bB1CAE03EaCF78Fc6d'), - [Chain.Polygon]: getAddress('0x7551b5D2763519d4e37e8B81929D336De671d46d'), - [Chain.Avalanche]: getAddress('0x65285E9dfab318f57051ab2b139ccCf232945451'), + [Chain.Ethereum]: [ + { + protocolDataProvider: getAddress( + '0x057835Ad21a177dbdd3090bB1CAE03EaCF78Fc6d', + ), + }, + ], + [Chain.Polygon]: [ + { + protocolDataProvider: getAddress( + '0x7551b5D2763519d4e37e8B81929D336De671d46d', + ), + }, + ], + [Chain.Avalanche]: [ + { + protocolDataProvider: getAddress( + '0x65285E9dfab318f57051ab2b139ccCf232945451', + ), + }, + ], }, [Protocol.AaveV3]: { - [Chain.Ethereum]: getAddress('0x7B4EB56E7CD4b454BA8ff71E4518426369a138a3'), - [Chain.Optimism]: getAddress('0x69FA688f1Dc47d4B5d8029D5a35FB7a548310654'), - [Chain.Arbitrum]: getAddress('0x69FA688f1Dc47d4B5d8029D5a35FB7a548310654'), - [Chain.Polygon]: getAddress('0x69FA688f1Dc47d4B5d8029D5a35FB7a548310654'), - [Chain.Fantom]: getAddress('0x69FA688f1Dc47d4B5d8029D5a35FB7a548310654'), - [Chain.Avalanche]: getAddress('0x69FA688f1Dc47d4B5d8029D5a35FB7a548310654'), - [Chain.Base]: getAddress('0x2d8A3C5677189723C4cB8873CfC9C8976FDF38Ac'), + [Chain.Ethereum]: [ + { + protocolDataProvider: getAddress( + '0x41393e5e337606dc3821075Af65AeE84D7688CBD', + ), + }, + { + marketLabel: 'Lido Market', + protocolDataProvider: getAddress( + '0x08795CFE08C7a81dCDFf482BbAAF474B240f31cD', + ), + }, + { + marketLabel: 'EtherFi Market', + protocolDataProvider: getAddress( + '0xE7d490885A68f00d9886508DF281D67263ed5758', + ), + }, + ], + [Chain.Optimism]: [ + { + protocolDataProvider: getAddress( + '0x69FA688f1Dc47d4B5d8029D5a35FB7a548310654', + ), + }, + ], + [Chain.Arbitrum]: [ + { + protocolDataProvider: getAddress( + '0x69FA688f1Dc47d4B5d8029D5a35FB7a548310654', + ), + }, + ], + [Chain.Polygon]: [ + { + protocolDataProvider: getAddress( + '0x69FA688f1Dc47d4B5d8029D5a35FB7a548310654', + ), + }, + ], + [Chain.Fantom]: [ + { + protocolDataProvider: getAddress( + '0x69FA688f1Dc47d4B5d8029D5a35FB7a548310654', + ), + }, + ], + [Chain.Avalanche]: [ + { + protocolDataProvider: getAddress( + '0x69FA688f1Dc47d4B5d8029D5a35FB7a548310654', + ), + }, + ], + [Chain.Base]: [ + { + protocolDataProvider: getAddress( + '0x2d8A3C5677189723C4cB8873CfC9C8976FDF38Ac', + ), + }, + ], + [Chain.Bsc]: [ + { + protocolDataProvider: getAddress( + '0x23dF2a19384231aFD114b036C14b6b03324D79BC', + ), + }, + ], }, } @@ -165,45 +255,56 @@ export abstract class AaveBasePoolAdapter implements IProtocolAdapter { } async getProtocolTokens(): Promise { - const protocolDataProviderContract = ProtocolDataProvider__factory.connect( - protocolDataProviderContractAddresses[this.protocolId]![this.chainId]!, - this.provider, - ) - - const reserveTokens = - await protocolDataProviderContract.getAllReservesTokens() - - const metadataObject: ProtocolToken[] = [] - - const promises = reserveTokens.map(async ({ tokenAddress }) => { - const reserveTokenAddresses = - await protocolDataProviderContract.getReserveTokensAddresses( - tokenAddress, - ) - - const protocolTokenPromise = this.helpers.getTokenMetadata( - this.getReserveTokenAddress(reserveTokenAddresses), + const dataProviderEntry = + protocolDataProviderContractAddresses[this.protocolId]![this.chainId]! + + const factories = Array.isArray(dataProviderEntry) + ? dataProviderEntry + : [{ protocolDataProvider: dataProviderEntry, marketLabel: undefined }] + + return ( + await Promise.all( + factories.map(async ({ protocolDataProvider, marketLabel }) => { + const protocolDataProviderContract = + ProtocolDataProvider__factory.connect( + protocolDataProvider, + this.provider, + ) + + const reserveTokens = + await protocolDataProviderContract.getAllReservesTokens() + + return await filterMapAsync( + reserveTokens, + async ({ tokenAddress }) => { + const reserveTokenAddresses = + await protocolDataProviderContract.getReserveTokensAddresses( + tokenAddress, + ) + + const [protocolToken, underlyingToken] = await Promise.all([ + this.helpers.getTokenMetadata( + this.getReserveTokenAddress(reserveTokenAddresses), + ), + this.helpers.getTokenMetadata(tokenAddress), + ]) + + if (protocolToken.address === ZERO_ADDRESS) { + return undefined + } + + return { + ...protocolToken, + name: `${protocolToken.name}${ + marketLabel ? ` (${marketLabel})` : '' + }`, + underlyingTokens: [underlyingToken], + } + }, + ) + }), ) - const underlyingTokenPromise = this.helpers.getTokenMetadata(tokenAddress) - - const [protocolToken, underlyingToken] = await Promise.all([ - protocolTokenPromise, - underlyingTokenPromise, - ]) - - if (protocolToken.address === ZERO_ADDRESS) { - return - } - - metadataObject.push({ - ...protocolToken, - underlyingTokens: [underlyingToken], - }) - }) - - await Promise.all(promises) - - return metadataObject + ).flat() } protected async getProtocolToken( diff --git a/packages/adapters-library/src/adapters/aave-v2/products/rewards/aaveV2RewardsAdapter.ts b/packages/adapters-library/src/adapters/aave-v2/products/rewards/aaveV2RewardsAdapter.ts index b07128e03..4677afbbc 100644 --- a/packages/adapters-library/src/adapters/aave-v2/products/rewards/aaveV2RewardsAdapter.ts +++ b/packages/adapters-library/src/adapters/aave-v2/products/rewards/aaveV2RewardsAdapter.ts @@ -101,7 +101,8 @@ export class AaveV2RewardsAdapter implements IProtocolAdapter { ) const protocolDataProvider = ProtocolDataProvider__factory.connect( - protocolDataProviderContractAddresses[this.protocolId]![this.chainId]!, + protocolDataProviderContractAddresses[this.protocolId]![this.chainId]![0]! + .protocolDataProvider, this.provider, ) diff --git a/packages/adapters-library/src/adapters/aave-v3/products/a-token/tests/snapshots/ethereum.positions.lido-market.json b/packages/adapters-library/src/adapters/aave-v3/products/a-token/tests/snapshots/ethereum.positions.lido-market.json new file mode 100644 index 000000000..1ea461285 --- /dev/null +++ b/packages/adapters-library/src/adapters/aave-v3/products/a-token/tests/snapshots/ethereum.positions.lido-market.json @@ -0,0 +1,51 @@ +{ + "blockNumber": 21330292, + "latency": "Latency: 1.038 seconds", + "aggregatedValues": ["USD422,914.82"], + "snapshot": [ + { + "protocolId": "aave-v3", + "name": "Aave v3 AToken", + "description": "Aave v3 defi adapter for yield-generating token", + "siteUrl": "https://aave.com/", + "iconUrl": "https://cryptologos.cc/logos/aave-aave-logo.png", + "positionType": "supply", + "chainId": 1, + "productId": "a-token", + "chainName": "ethereum", + "success": true, + "tokens": [ + { + "address": "0xfA1fDbBD71B0aA16162D76914d69cD8CB3Ef92da", + "name": "Aave Ethereum Lido WETH", + "symbol": "aEthLidoWETH", + "decimals": 18, + "balanceRaw": "111290153207368083227n", + "type": "protocol", + "tokens": [ + { + "address": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", + "name": "Wrapped Ether", + "symbol": "WETH", + "decimals": 18, + "type": "underlying", + "balanceRaw": "111290153207368083227n", + "balance": 111.29015320736808, + "price": 3800.11, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/ethereum/assets/0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2/logo.png" + } + ], + "balance": 111.29015320736808 + } + ] + } + ], + "rpcResponses": { + "c73cfc074e1255e7715b9bbaec5d84f5": { + "result": "0x00000000000000000000000000000000000000000000000608760cb39bf9671b" + }, + "2e8c205a0104fe2340d426989c7c3da7": { + "result": "0x0000000000000000000000000000000000000000000000070000000000000cca000000000000000000000000000000000000000000000000000000587a6bb0c00000000000000000000000000000000000000000000000000000000067508006000000000000000000000000000000000000000000000000000000006750801b0000000000000000000000000000000000000000000000070000000000000cca" + } + } +} diff --git a/packages/adapters-library/src/adapters/aave-v3/products/a-token/tests/testCases.ts b/packages/adapters-library/src/adapters/aave-v3/products/a-token/tests/testCases.ts index ea5c0337a..674d195fc 100644 --- a/packages/adapters-library/src/adapters/aave-v3/products/a-token/tests/testCases.ts +++ b/packages/adapters-library/src/adapters/aave-v3/products/a-token/tests/testCases.ts @@ -19,6 +19,18 @@ export const testCases: TestCase[] = [ blockNumber: 19818581, }, + { + key: 'lido-market', + chainId: Chain.Ethereum, + method: 'positions', + + input: { + userAddress: '0xb83F1688C0b7ebb155a830ae78F71527Ef55e759', + filterProtocolTokens: ['0xfA1fDbBD71B0aA16162D76914d69cD8CB3Ef92da'], + }, + + blockNumber: 21330292, + }, { chainId: Chain.Ethereum, method: 'profits', diff --git a/packages/adapters-library/src/adapters/aave-v3/products/rewards/aaveV3RewardsAdapter.ts b/packages/adapters-library/src/adapters/aave-v3/products/rewards/aaveV3RewardsAdapter.ts index 1ad5fa231..0a873b6af 100644 --- a/packages/adapters-library/src/adapters/aave-v3/products/rewards/aaveV3RewardsAdapter.ts +++ b/packages/adapters-library/src/adapters/aave-v3/products/rewards/aaveV3RewardsAdapter.ts @@ -8,10 +8,10 @@ import { NotImplementedError, } from '../../../../core/errors/errors' import { CustomJsonRpcProvider } from '../../../../core/provider/CustomJsonRpcProvider' +import { filterMapAsync } from '../../../../core/utils/filters' import { logger } from '../../../../core/utils/logger' import { Helpers } from '../../../../scripts/helpers' import { - Erc20ExtendedMetadata, IProtocolAdapter, ProtocolToken, } from '../../../../types/IProtocolAdapter' @@ -26,7 +26,6 @@ import { ProtocolPosition, ProtocolTokenTvl, TokenType, - Underlying, UnwrapExchangeRate, UnwrapInput, } from '../../../../types/adapter' @@ -116,32 +115,6 @@ export class AaveV3RewardsAdapter implements IProtocolAdapter { } } - /** - * - * AToken addresses required to query reward balances - */ - async getAaveTokenAddresses(): Promise { - const [aTokens, stableDebtTokens, variableDebtTokens] = await Promise.all([ - this.helpers.metadataProvider.getMetadata({ - protocolId: Protocol.AaveV3, - productId: 'a-token', - }), - this.helpers.metadataProvider.getMetadata({ - protocolId: Protocol.AaveV3, - productId: 'stable-debt-token', - }), - this.helpers.metadataProvider.getMetadata({ - protocolId: Protocol.AaveV3, - productId: 'variable-debt-token', - }), - ]) - return [ - ...aTokens.map((token) => token.address), - ...stableDebtTokens.map((token) => token.address), - ...variableDebtTokens.map((token) => token.address), - ] - } - @CacheToDb async getProtocolTokens(): Promise { const rewardTokenAddresses = await this.incentivesContract.getRewardsList() @@ -178,7 +151,12 @@ export class AaveV3RewardsAdapter implements IProtocolAdapter { toBlock: 'latest', }) - const aTokenAddresses = await this.getAaveTokenAddresses() + const aTokenAddresses = ( + await this.helpers.metadataProvider.getMetadata({ + protocolId: Protocol.AaveV3, + productId: 'a-token', + }) + ).map((token) => token.address) const filteredLogs = logs .filter((log) => aTokenAddresses.includes(log.address)) @@ -187,19 +165,18 @@ export class AaveV3RewardsAdapter implements IProtocolAdapter { return [...new Set(filteredLogs)] } - async getPositions(input: GetPositionsInput): Promise { - // Fetch reward contract details + async getPositions({ + userAddress, + blockNumber, + protocolTokenAddresses, + }: GetPositionsInput): Promise { const protocolTokens = await this.getProtocolTokens() const protocolToken = protocolTokens[0] - const { userAddress, blockNumber, protocolTokenAddresses } = input - - // If no protocolToken is found throw an error if (!protocolToken) { throw new Error('No protocol token found') } - // If protocolTokenAddresses are provided, check if this protocolToken is in the list if ( protocolTokenAddresses && protocolTokenAddresses.length > 0 && @@ -208,27 +185,41 @@ export class AaveV3RewardsAdapter implements IProtocolAdapter { return [] } - // Check if user has ever opened a position in AaveV3 const addressFilter = await this.openPositions(userAddress) - // Return empty array if user has never opened a AaveV3 position - if (!addressFilter?.length) { + if (!addressFilter.length) { return [] } - // Fetch and filter underlying tokens with non-zero rewards in parallel - const underlyingTokens = await this.getClaimableUnderlyingTokens( + const userRewards = await this.incentivesContract.getAllUserRewards( + addressFilter, userAddress, - protocolToken.underlyingTokens, - blockNumber, + { blockTag: blockNumber }, + ) + + const underlyingTokens = await filterMapAsync( + userRewards.unclaimedAmounts, + async (unclaimedAmount, i) => { + if (!unclaimedAmount) { + return undefined + } + + const underlying = protocolToken.underlyingTokens.find( + (underlying) => underlying.address === userRewards.rewardsList[i], + )! + + return { + ...underlying, + type: TokenType.UnderlyingClaimable, + balanceRaw: unclaimedAmount, + } + }, ) - // If no claimable underlying tokens are found, return empty if (underlyingTokens.length === 0) { return [] } - // Return the final ProtocolPosition object return [ { type: TokenType.Protocol, @@ -239,37 +230,6 @@ export class AaveV3RewardsAdapter implements IProtocolAdapter { ] } - /** - * - * Fetches claimable underlying tokens for a user - */ - private async getClaimableUnderlyingTokens( - userAddress: string, - underlyingTokens: Erc20ExtendedMetadata[], - blockNumber?: number, - ): Promise { - const tokenRewards = await Promise.all( - underlyingTokens.map(async (underlying) => { - const rewardBalance = - await this.incentivesContract.getUserAccruedRewards( - userAddress, - underlying.address, - { blockTag: blockNumber }, - ) - return { rewardBalance, underlying } - }), - ) - - // Filter out tokens with zero rewards - return tokenRewards - .filter(({ rewardBalance }) => rewardBalance > 0n) - .map(({ rewardBalance, underlying }) => ({ - ...underlying, - type: TokenType.UnderlyingClaimable, - balanceRaw: rewardBalance, - })) - } - /** * Rewards claimed by a user */ diff --git a/packages/adapters-library/src/adapters/aave-v3/products/rewards/tests/snapshots/ethereum.positions.lido-market.json b/packages/adapters-library/src/adapters/aave-v3/products/rewards/tests/snapshots/ethereum.positions.lido-market.json new file mode 100644 index 000000000..d40c0d8a0 --- /dev/null +++ b/packages/adapters-library/src/adapters/aave-v3/products/rewards/tests/snapshots/ethereum.positions.lido-market.json @@ -0,0 +1,146 @@ +{ + "blockNumber": 21330297, + "latency": "Latency: 1.428 seconds", + "aggregatedValues": ["USD241.56"], + "snapshot": [ + { + "protocolId": "aave-v3", + "name": "AaveV3", + "description": "AaveV3 defi adapter", + "siteUrl": "https:", + "iconUrl": "https://cryptologos.cc/logos/aave-aave-logo.png", + "positionType": "supply", + "chainId": 1, + "productId": "rewards", + "chainName": "ethereum", + "success": true, + "tokens": [ + { + "type": "protocol", + "balanceRaw": "1n", + "address": "0x8164Cc65827dcFe994AB23944CBC90e0aa80bFcb", + "name": "Aave V3 Rewards", + "symbol": "Rewards", + "decimals": 18, + "tokens": [ + { + "address": "0xfA1fDbBD71B0aA16162D76914d69cD8CB3Ef92da", + "name": "Aave Ethereum Lido WETH", + "symbol": "aEthLidoWETH", + "decimals": 18, + "type": "underlying-claimable", + "balanceRaw": "63565426583012635n", + "tokens": [ + { + "address": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", + "name": "Wrapped Ether", + "symbol": "WETH", + "decimals": 18, + "type": "underlying-claimable", + "balanceRaw": "63565426583012635n", + "balance": 0.06356542658301263, + "price": 3800.11, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/ethereum/assets/0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2/logo.png" + } + ], + "balance": 0.06356542658301263, + "price": 3800.11, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/ethereum/assets/0xfA1fDbBD71B0aA16162D76914d69cD8CB3Ef92da/logo.png" + } + ], + "balance": 1e-18 + } + ] + } + ], + "rpcResponses": { + "722d93233a3a8540be9aab386f5dcb9c": { + "result": [ + { + "address": "0xfa1fdbbd71b0aa16162d76914d69cd8cb3ef92da", + "blockHash": "0x44c72601129623d0313890319574a2de831f1416f7b35b1f634f5beb1d930b24", + "blockNumber": "0x140741e", + "data": "0x0000000000000000000000000000000000000000000000000003afa3fe1bed2c", + "logIndex": "0x18f", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b83f1688c0b7ebb155a830ae78f71527ef55e759" + ], + "transactionHash": "0xf6aa2474714ed7ffe649e32a58fc695d44e6d339f92a18ed4eeb7a2752236afa", + "transactionIndex": "0x59" + }, + { + "address": "0xfa1fdbbd71b0aa16162d76914d69cd8cb3ef92da", + "blockHash": "0xbe5c31be384dcd6105e678a3c6f2eb12d7e3634069d801ec39d43d4a1e3d162f", + "blockNumber": "0x1408fe9", + "data": "0x0000000000000000000000000000000000000000000000070c23778c146a7389", + "logIndex": "0x1a7", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b83f1688c0b7ebb155a830ae78f71527ef55e759" + ], + "transactionHash": "0x85a372f5e6fef92a70b497deff9d5c2abb59c80cf5fb02431dce35e952637b0a", + "transactionIndex": "0xa2" + }, + { + "address": "0xfa1fdbbd71b0aa16162d76914d69cd8cb3ef92da", + "blockHash": "0x2c207e0c4899c54697ecff37d075ffc13f482e898d61002bf8c95d8288996b0b", + "blockNumber": "0x141a9bc", + "data": "0x000000000000000000000000000000000000000000000000013898b4c41d2f27", + "logIndex": "0x5b", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b83f1688c0b7ebb155a830ae78f71527ef55e759" + ], + "transactionHash": "0xc36dc3a31caf4947aa4fed76e58e4455914c165b2bab5a866de0f3feb1161206", + "transactionIndex": "0x12" + }, + { + "address": "0xfa1fdbbd71b0aa16162d76914d69cd8cb3ef92da", + "blockHash": "0x69144a80479073a074fba45de763695609a624cdc2477b1a67c83540e91e196c", + "blockNumber": "0x141bfbc", + "data": "0x000000000000000000000000000000000000000000000000000f53509a16cfc7", + "logIndex": "0x30", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b83f1688c0b7ebb155a830ae78f71527ef55e759" + ], + "transactionHash": "0x1ffbad7e5bb9708850bd73266f869fd5a1939c1400659b0131fcfbe1f5e0a5cc", + "transactionIndex": "0xe" + }, + { + "address": "0xfa1fdbbd71b0aa16162d76914d69cd8cb3ef92da", + "blockHash": "0x28cce89a182748a46a8abfdf7783b8dfd4a32228fa9750ad2d2a2fee09b14b41", + "blockNumber": "0x143dffa", + "data": "0x0000000000000000000000000000000000000000000000000193127a3ac823ba", + "logIndex": "0x243", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b83f1688c0b7ebb155a830ae78f71527ef55e759" + ], + "transactionHash": "0x441b624cd6404ce43b8342b2d21ca959cfc074600ed13b981733e490ffd0adad", + "transactionIndex": "0x145" + } + ] + }, + "69057aaddf713aa03377f33446bbf2a4": { + "result": "0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000500000000000000000000000030d20208d987713f46dfd34ef128bb16c404d10f000000000000000000000000fa1fdbbd71b0aa16162d76914d69cd8cb3ef92da0000000000000000000000007f39c581f595b53c5cb19bd0b3f8da6c935e2ca000000000000000000000000032a6268f9ba3642dda7892add74f1d34469a4259000000000000000000000000c035a7cf15375ce2706766804551791ad035e0c20000000000000000000000000000000000000000000000000000000000000005000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e1d46b2f7a051b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "a0ebca2cf82553427fb4b4845f4200fa": { + "result": "0x0000000000000000000000000000000000000000000000070000000000000cca000000000000000000000000000000000000000000000000000000587a6bb0c00000000000000000000000000000000000000000000000000000000067508006000000000000000000000000000000000000000000000000000000006750801b0000000000000000000000000000000000000000000000070000000000000cca" + }, + "f1f64dce24280cbd215071f3c34f1d6a": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000000" + } + } +} diff --git a/packages/adapters-library/src/adapters/aave-v3/products/rewards/tests/testCases.ts b/packages/adapters-library/src/adapters/aave-v3/products/rewards/tests/testCases.ts index 798ebd4c0..7ab47eec8 100644 --- a/packages/adapters-library/src/adapters/aave-v3/products/rewards/tests/testCases.ts +++ b/packages/adapters-library/src/adapters/aave-v3/products/rewards/tests/testCases.ts @@ -1,7 +1,6 @@ import { Chain } from '../../../../../core/constants/chains' import { TimePeriod } from '../../../../../core/constants/timePeriod' import type { TestCase } from '../../../../../types/testCase' -import { WriteActions } from '../../../../../types/writeActions' export const testCases: TestCase[] = [ { @@ -16,6 +15,18 @@ export const testCases: TestCase[] = [ blockNumber: 264107941, }, + { + key: 'lido-market', + chainId: Chain.Ethereum, + method: 'positions', + + input: { + userAddress: '0xb83F1688C0b7ebb155a830ae78F71527Ef55e759', + filterProtocolTokens: ['0x8164Cc65827dcFe994AB23944CBC90e0aa80bFcb'], + }, + + blockNumber: 21330297, + }, { chainId: Chain.Arbitrum, method: 'profits', diff --git a/packages/adapters-library/src/adapters/stakewise/products/os-eth/stakeWiseOsEthAdapter.ts b/packages/adapters-library/src/adapters/stakewise/products/os-eth/stakeWiseOsEthAdapter.ts index 1d4f8f6e3..93ed2d5fe 100644 --- a/packages/adapters-library/src/adapters/stakewise/products/os-eth/stakeWiseOsEthAdapter.ts +++ b/packages/adapters-library/src/adapters/stakewise/products/os-eth/stakeWiseOsEthAdapter.ts @@ -59,20 +59,15 @@ export class StakeWiseOsEthAdapter extends SimplePoolAdapter { @CacheToDb async getProtocolTokens(): Promise { + const [protocolToken, underlyingToken] = await Promise.all([ + this.helpers.getTokenMetadata(PROTOCOL_TOKEN_ADDRESS), + this.helpers.getTokenMetadata(ZERO_ADDRESS), + ]) + return [ { - name: 'StakeWise osETH', - symbol: 'osETH', - decimals: 18, - address: PROTOCOL_TOKEN_ADDRESS, - underlyingTokens: [ - { - address: ZERO_ADDRESS, - name: 'Ethereum', - symbol: 'ETH', - decimals: 18, - }, - ], + ...protocolToken, + underlyingTokens: [underlyingToken], }, ] } diff --git a/packages/adapters-library/src/adapters/stakewise/products/os-eth/tests/snapshots/ethereum.deposits.json b/packages/adapters-library/src/adapters/stakewise/products/os-eth/tests/snapshots/ethereum.deposits.json index f5fb3b59e..2b31a7f72 100644 --- a/packages/adapters-library/src/adapters/stakewise/products/os-eth/tests/snapshots/ethereum.deposits.json +++ b/packages/adapters-library/src/adapters/stakewise/products/os-eth/tests/snapshots/ethereum.deposits.json @@ -17,14 +17,14 @@ "transactionHash": "0x3663c0556b9cedb1417bb2559e80e473a811fc61a9883d4b51f464d3aa9c2f53", "protocolToken": { "address": "0xf1C9acDc66974dFB6dEcB12aA385b9cD01190E38", - "name": "StakeWise osETH", + "name": "Staked ETH", "symbol": "osETH", "decimals": 18 }, "tokens": [ { "address": "0xf1C9acDc66974dFB6dEcB12aA385b9cD01190E38", - "name": "StakeWise osETH", + "name": "Staked ETH", "symbol": "osETH", "decimals": 18, "balanceRaw": "100000000000000n", diff --git a/packages/adapters-library/src/adapters/stakewise/products/os-eth/tests/snapshots/ethereum.positions.json b/packages/adapters-library/src/adapters/stakewise/products/os-eth/tests/snapshots/ethereum.positions.json index e3102d8ba..170778f74 100644 --- a/packages/adapters-library/src/adapters/stakewise/products/os-eth/tests/snapshots/ethereum.positions.json +++ b/packages/adapters-library/src/adapters/stakewise/products/os-eth/tests/snapshots/ethereum.positions.json @@ -17,7 +17,7 @@ "tokens": [ { "address": "0xf1C9acDc66974dFB6dEcB12aA385b9cD01190E38", - "name": "StakeWise osETH", + "name": "Staked ETH", "symbol": "osETH", "decimals": 18, "balanceRaw": "100000000000000n", diff --git a/packages/adapters-library/src/adapters/stakewise/products/os-eth/tests/snapshots/ethereum.prices.json b/packages/adapters-library/src/adapters/stakewise/products/os-eth/tests/snapshots/ethereum.prices.json index 159d4db2e..223496ec8 100644 --- a/packages/adapters-library/src/adapters/stakewise/products/os-eth/tests/snapshots/ethereum.prices.json +++ b/packages/adapters-library/src/adapters/stakewise/products/os-eth/tests/snapshots/ethereum.prices.json @@ -16,7 +16,7 @@ "tokens": [ { "address": "0xf1C9acDc66974dFB6dEcB12aA385b9cD01190E38", - "name": "StakeWise osETH", + "name": "Staked ETH", "decimals": 18, "symbol": "osETH", "baseRate": 1, diff --git a/packages/adapters-library/src/adapters/stakewise/products/os-eth/tests/snapshots/ethereum.profits.json b/packages/adapters-library/src/adapters/stakewise/products/os-eth/tests/snapshots/ethereum.profits.json index 44fe67923..bc802abbe 100644 --- a/packages/adapters-library/src/adapters/stakewise/products/os-eth/tests/snapshots/ethereum.profits.json +++ b/packages/adapters-library/src/adapters/stakewise/products/os-eth/tests/snapshots/ethereum.profits.json @@ -16,7 +16,7 @@ "tokens": [ { "address": "0xf1C9acDc66974dFB6dEcB12aA385b9cD01190E38", - "name": "StakeWise osETH", + "name": "Staked ETH", "symbol": "osETH", "decimals": 18, "type": "protocol", diff --git a/packages/adapters-library/src/adapters/stakewise/products/os-eth/tests/snapshots/ethereum.tvl.json b/packages/adapters-library/src/adapters/stakewise/products/os-eth/tests/snapshots/ethereum.tvl.json index 5dd5ddfbc..905def20e 100644 --- a/packages/adapters-library/src/adapters/stakewise/products/os-eth/tests/snapshots/ethereum.tvl.json +++ b/packages/adapters-library/src/adapters/stakewise/products/os-eth/tests/snapshots/ethereum.tvl.json @@ -16,7 +16,7 @@ "tokens": [ { "address": "0xf1C9acDc66974dFB6dEcB12aA385b9cD01190E38", - "name": "StakeWise osETH", + "name": "Staked ETH", "decimals": 18, "symbol": "osETH", "type": "protocol", diff --git a/packages/adapters-library/src/adapters/stakewise/products/os-eth/tests/snapshots/ethereum.withdrawals.json b/packages/adapters-library/src/adapters/stakewise/products/os-eth/tests/snapshots/ethereum.withdrawals.json index de4bc0388..e5f53e63b 100644 --- a/packages/adapters-library/src/adapters/stakewise/products/os-eth/tests/snapshots/ethereum.withdrawals.json +++ b/packages/adapters-library/src/adapters/stakewise/products/os-eth/tests/snapshots/ethereum.withdrawals.json @@ -17,14 +17,14 @@ "transactionHash": "0x0c7ac7cd9bff94bbff40659462195ffdd343b88cec34189387d047998e56cdcd", "protocolToken": { "address": "0xf1C9acDc66974dFB6dEcB12aA385b9cD01190E38", - "name": "StakeWise osETH", + "name": "Staked ETH", "symbol": "osETH", "decimals": 18 }, "tokens": [ { "address": "0xf1C9acDc66974dFB6dEcB12aA385b9cD01190E38", - "name": "StakeWise osETH", + "name": "Staked ETH", "symbol": "osETH", "decimals": 18, "balanceRaw": "1000000000000n", From f65f6ae8bfb5eddfb9b17abe1389203c89736e2a Mon Sep 17 00:00:00 2001 From: jpsains <32621022+jpsains@users.noreply.github.com> Date: Fri, 6 Dec 2024 12:32:19 +0000 Subject: [PATCH 3/4] feat: zerolend (#384) * feat: zerolend * feat: fix * feat: fix * lint * remove rogue entry * access modifier for private methods --------- Co-authored-by: Bernardo Garces Chapero --- linea.db | Bin 221184 -> 221184 bytes .../src/adapters/integration.test.ts | 2 + .../src/adapters/supportedProtocols.ts | 3 + .../adapters/zerolend/contracts/Vesting.ts | 1639 ++++++++++++++++ .../zerolend/contracts/abis/vesting.json | 1 + .../contracts/factories/Vesting__factory.ts | 1656 +++++++++++++++++ .../zerolend/contracts/factories/index.ts | 1 + .../src/adapters/zerolend/contracts/index.ts | 2 + .../tests/snapshots/ethereum.profits.json | 6 +- .../a-token/tests/snapshots/ethereum.tvl.json | 6 +- .../snapshots/linea.positions.vesting-2.json | 60 + .../snapshots/linea.positions.vesting.json | 102 + .../products/vesting/tests/testCases.ts | 31 + .../vesting/zerolendVestingAdapter.ts | 276 +++ 14 files changed, 3779 insertions(+), 6 deletions(-) create mode 100644 packages/adapters-library/src/adapters/zerolend/contracts/Vesting.ts create mode 100644 packages/adapters-library/src/adapters/zerolend/contracts/abis/vesting.json create mode 100644 packages/adapters-library/src/adapters/zerolend/contracts/factories/Vesting__factory.ts create mode 100644 packages/adapters-library/src/adapters/zerolend/products/vesting/tests/snapshots/linea.positions.vesting-2.json create mode 100644 packages/adapters-library/src/adapters/zerolend/products/vesting/tests/snapshots/linea.positions.vesting.json create mode 100644 packages/adapters-library/src/adapters/zerolend/products/vesting/tests/testCases.ts create mode 100644 packages/adapters-library/src/adapters/zerolend/products/vesting/zerolendVestingAdapter.ts diff --git a/linea.db b/linea.db index ad0e4f3da76b54cb1ffb01ab57797a32c0af7b94..9e1b45ddb4c2d31dbef67e0085abaa241b55c877 100644 GIT binary patch delta 5542 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 delta 4358 zcmZWs33wG%macQE>Q%ixL6(j{2%-tRm*qVc*&28u>|seDY#|A$1j)X!1_Y8AoDQPz z>CgT~kYJ;Jj$;ezH;AHy%>_i}+zS0oGn4vK=l%0NakDkAH ze(5Rpqmm~+E&Tq_WrZC$~)PsdEWCJ@HBX4xIc1lb^nfO zE8X2&UmrGJ)!xaF4QgltzfJoOZX!Lu1bpVTEA2MzjKJoVl|Gx+YndAUfIjoHt8ChD znKI`2%mdeg>Qc*^Tf)y_$geci@)O<>c0 zYbn~d3FC8CJHCL8p&wcRa?GS<>1N-}0BSFq^||S0&aEQU>dmfO5y&+|Kdyyrv-8Ic zm}~a_n2y@7p1#fR1~VYUGiLE^Chs$Q1lnx&31oKX{B&gGlsVE_Nja`W6$8&>u6#y* zL2i&U<#_3=)@Sc@_jp6zI2`G0_B4BPTp?Sp^PHYzuXpvj`)GO+B-8pN2*T&FjwHAU zsGXvg2jDWyqJ~lM25P^f;DbUwNmm{O{`3|a`4F4uQ+zTQvLt0tiz55z`D6&dGU`o+ zwJ?tYDT3Nb#VHIIP>&D`DQPr|MbtbR!l+eJ+!!HWqRugp0eRFr26#v{6z~ak9rgGG z-bzV+f&Z1d`~ts1aj8N+P4%g;o*qtv(KfBzlO(m%C+m39q14kQ^^rRhxV?tkJx|y9 z5W>`+1_A0#6>&Y=kp}6p#B_MiX48IYC8_0SvM)Aj0wjT=ZOD-6g(gU~X>VJ$s0Vy> z;9=-d8!bFlmwl)$HhXi^V{cA`#hmq8%McXA&}3*=wRToe^i%YAOo3vX_OfMfiD!HJ z6gaNVv2fiC{%G@5IK;F5E(NEF*oX{EK1I=KJS|J;_%t#6O|jhRu!wo5sdEO;;_Ra# zP?F-N$@?Ym$^YF#w4xXuKxYzd7gB2^y%>@YM-$}O{!;ivMu%bsY6Eg`kDU&c!8p_v zv#&Cs2lr?S81Xx)Ydxf^HqoXt7r?JRx-+;(rKWPGDvH@tC8)A6Z=;6Q=(FrdLn~k$ z04-sGl47=3Gp(&j&^A-%81&iMP1`QZt8ua4Yuip5Q3+$UwjDyfp`#Ykw6;e@yTLsC z7`L~JcD-wKZBU;=cjELwMXOU=6h_gH$cpw#71D`SPy+&2+3v_}?Vd zm1cZdD#x@@fC{s{Dpd})ZJ;&PFc#YyC}PQa^L9zl7Hq3y5;f<*Ff;B}oE3Vl<+|n4 zUDq|VwnlWUCL>pTqDq(zx>5kbZ6)2ZtQC||D_G?eTq;;)f>mf9FBPQqbc&VO_6Wf; zVO%GStEs(8Ohc&vt3)mslnAg=#LwM~*y%d>c@iX%s~v{gM{_L||GsXh@AV$-1SL++ zmQIk?1x-K0JNPydmSP6ng15lrMdO#glTJjV57CJ(7|-t3Qko&6C?bQUt*uaeiw=K! zcYX^5%r(zH&M89g*g=JcJi--{Dso@;+rX~#7!kbki%TIN8IE43_&@V3t=TTJ|W^3VPsu3Io zbe_v1T`0p5w(wHbm^_qz`kuKH%Y`CWHKq=sgST1ni*iiV!a1suF&wCQCii*29EaM% zOPDg0be-qqfeK8rg%_*Fw4pRbC^lB$NG-gGBNz%aB8&U{xdI==@Iv~k0<&%5Y}J@B zoL&&Il~oG&3shqaQ{NEOqm?)W!}IBMC1zuI9u2F)Ss0#6!8C%_%ZVM%T#bPt%u+TPH3{fDNzR?2ZRDYR6+F*e)tLke?gM~~e^=nGK)uxsl z7%B=TDs{Bu61%LWgF@8MITl*A#WKVVOjD}*yWFW^$4X^CfTd!}D=bjdKaz3_h?2?i zmXYflcGpPLg;-DZEVM@~hE+E?;B^+_!pX_dN-ZD?CtFG^utJOr6@w}-vx{PSPKdSi z4vVrPH|&;1auWHLImz=^Pqio6eZt-59_2dcdek-8dB|DqbUI4xH|!z(y#A~{RpV1g z{aUS2$13NQCS|z%CwUFt!u>e)A0O%D-RC*!IrnAvB^&c6@($DGL^-r)JniekkYFYl2}6K-XM=Cx z?7Vqt3v-tFSPrniD19V+SUYEaE4x^{Cm?n_khmUE>tRgN_GIur9s=gB5+9vCjQ7W$ z1x}q((mGtFJ_KX1<1J~4;ZK1;3JBEi&}?J*BUI+L#>0kR|1IaQQT^bm)ErpqWA)Q1Y7T;=1qL6wZ_xO z1>8H-8mCgtYMddLw0dd5W>!sV^{CXf8Yjxdt!_HB8H@F-R+lIlU=~;VC?OvQD(hOE zDz)%+k^9-Hp-8yY=xH2wvhH+!AA&FTrp9L#YGH~xkneOS>9~VSyLK=((us+Di7TT_moP+P z4KA+jsO_a*uTXRxjY9~P>Mkh_5+v=n+AP~Aw(Yk2)Gjq!`ER8~xnKT+oQD_iF?XG7 zpz}j#hvQpEw&9`yvK-onF&l)3@s59Cgk-_Yl`9*BKNTI0+KC6CNnH-2m&5Ga`u z;ge?+M=)}qk9>I;r-ULY{p&!P6iMz+zn&F&=>KHh{TlyX={>?nV`e0mP9MQcWo{%# zrNFB=hdP(xDtS&MiK07kj?T+6cz2Lv=#5%@Iri5TI2x3hk)5xQv zFBIw8oc@Pudtn#iILgS!x%%`l@7sS||FJD+U@AfDJKoshv%=hCZ3so% zE$!gxoTy9>dsRAi6Q=1?!!y-;Hfe142e3m=b$bs=@s4*TZ;5x1=RZBa@+|knyHE2k zm%}7$Ilx59T#gIjVbe2nzS!_fslFB$A8ke@3Fea8iBWVs zAA6<~r?~MXQcDM>b{xcVm8s*9k_b}~=En9P#EKR5qMZ}=U6yrP gdJIR$u0AXeNRS8GJ*4HxV|bW<(_^01@>Sda0IMDO0{{R3 diff --git a/packages/adapters-library/src/adapters/integration.test.ts b/packages/adapters-library/src/adapters/integration.test.ts index f8152c416..9a0635a1b 100644 --- a/packages/adapters-library/src/adapters/integration.test.ts +++ b/packages/adapters-library/src/adapters/integration.test.ts @@ -115,6 +115,7 @@ import { testCases as xfaiDexTestCases } from './xfai/products/dex/tests/testCas import { testCases as zeroLendATokenTestCases } from './zerolend/products/a-token/tests/testCases' import { testCases as zeroLendStableDebtTokenTestCases } from './zerolend/products/stable-debt-token/tests/testCases' import { testCases as zeroLendVariableDebtTokenTestCases } from './zerolend/products/variable-debt-token/tests/testCases' +import { testCases as zerolendVestingTestCases } from './zerolend/products/vesting/tests/testCases' const TEST_TIMEOUT = 300000 @@ -369,6 +370,7 @@ const allTestCases: Record> = { }, [Protocol.ZeroLend]: { + ['vesting']: zerolendVestingTestCases, ['a-token']: zeroLendATokenTestCases, ['stable-debt-token']: zeroLendStableDebtTokenTestCases, ['variable-debt-token']: zeroLendVariableDebtTokenTestCases, diff --git a/packages/adapters-library/src/adapters/supportedProtocols.ts b/packages/adapters-library/src/adapters/supportedProtocols.ts index 46afabfa6..dbbd50bec 100644 --- a/packages/adapters-library/src/adapters/supportedProtocols.ts +++ b/packages/adapters-library/src/adapters/supportedProtocols.ts @@ -153,6 +153,8 @@ import { BalancerV2FarmingAdapter } from './balancer-v2/products/farming/balance import { MendiFinanceStakingAdapter } from './mendi-finance/products/staking/mendiFinanceStakingAdapter' +import { ZerolendVestingAdapter } from './zerolend/products/vesting/zerolendVestingAdapter' + export const supportedProtocols: Record< Protocol, Partial< @@ -658,6 +660,7 @@ export const supportedProtocols: Record< ZeroLendVariableDebtTokenPoolAdapter, ], [Chain.Linea]: [ + ZerolendVestingAdapter, ZeroLendATokenPoolAdapter, ZeroLendStableDebtTokenPoolAdapter, ZeroLendVariableDebtTokenPoolAdapter, diff --git a/packages/adapters-library/src/adapters/zerolend/contracts/Vesting.ts b/packages/adapters-library/src/adapters/zerolend/contracts/Vesting.ts new file mode 100644 index 000000000..686d6e964 --- /dev/null +++ b/packages/adapters-library/src/adapters/zerolend/contracts/Vesting.ts @@ -0,0 +1,1639 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumberish, + BytesLike, + FunctionFragment, + Result, + Interface, + EventFragment, + AddressLike, + ContractRunner, + ContractMethod, + Listener, +} from "ethers"; +import type { + TypedContractEvent, + TypedDeferredTopicFilter, + TypedEventLog, + TypedLogDescription, + TypedListener, + TypedContractMethod, +} from "./common"; + +export declare namespace Checkpoints { + export type Checkpoint208Struct = { + _key: BigNumberish; + _value: BigNumberish; + }; + + export type Checkpoint208StructOutput = [_key: bigint, _value: bigint] & { + _key: bigint; + _value: bigint; + }; +} + +export declare namespace ILocker { + export type LockedBalanceStruct = { + amount: BigNumberish; + end: BigNumberish; + start: BigNumberish; + power: BigNumberish; + }; + + export type LockedBalanceStructOutput = [ + amount: bigint, + end: bigint, + start: bigint, + power: bigint + ] & { amount: bigint; end: bigint; start: bigint; power: bigint }; +} + +export interface VestingInterface extends Interface { + getFunction( + nameOrSignature: + | "CLOCK_MODE" + | "__" + | "allowance" + | "approve" + | "balanceOf" + | "checkpoints" + | "clock" + | "decimals" + | "delegate" + | "delegateBySig" + | "delegates" + | "distributor" + | "earned" + | "eip712Domain" + | "getLockedNftDetails" + | "getPastTotalSupply" + | "getPastVotes" + | "getReward" + | "getRewardETH" + | "getTokenPower" + | "getVotes" + | "increaseLockAmount" + | "increaseLockDuration" + | "init" + | "initDelegates" + | "lastTimeRewardApplicable" + | "lastUpdateTime" + | "lockedByToken" + | "lockedTokenIdNfts" + | "locker" + | "lpPower" + | "name" + | "nonces" + | "notifyRewardAmount" + | "numCheckpoints" + | "onERC721Received" + | "owner" + | "periodFinish" + | "recoverERC20" + | "renounceOwnership" + | "rewardPerToken" + | "rewardPerTokenStored" + | "rewardRate" + | "rewards" + | "rewardsDuration" + | "rewardsToken" + | "setRewardDistributor" + | "setVotingPowerCombined" + | "symbol" + | "tokenPower" + | "totalNFTStaked" + | "totalSupply" + | "transfer" + | "transferFrom" + | "transferOwnership" + | "unstakeAndWithdraw" + | "unstakeToken" + | "updateRewardFor" + | "userRewardPerTokenPaid" + | "votingPowerCombined" + ): FunctionFragment; + + getEvent( + nameOrSignatureOrTopic: + | "Approval" + | "DelegateChanged" + | "DelegateVotesChanged" + | "EIP712DomainChanged" + | "Initialized" + | "LpOracleSet" + | "OwnershipTransferred" + | "Recovered" + | "RewardAdded" + | "RewardPaid" + | "RewardsDurationUpdated" + | "RewardsTokenUpdated" + | "TokenLockerUpdated" + | "Transfer" + | "VotingPowerCombinedUpdated" + | "ZeroAggregatorSet" + ): EventFragment; + + encodeFunctionData( + functionFragment: "CLOCK_MODE", + values?: undefined + ): string; + encodeFunctionData(functionFragment: "__", values?: undefined): string; + encodeFunctionData( + functionFragment: "allowance", + values: [AddressLike, AddressLike] + ): string; + encodeFunctionData( + functionFragment: "approve", + values: [AddressLike, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "balanceOf", + values: [AddressLike] + ): string; + encodeFunctionData( + functionFragment: "checkpoints", + values: [AddressLike, BigNumberish] + ): string; + encodeFunctionData(functionFragment: "clock", values?: undefined): string; + encodeFunctionData(functionFragment: "decimals", values?: undefined): string; + encodeFunctionData( + functionFragment: "delegate", + values: [AddressLike] + ): string; + encodeFunctionData( + functionFragment: "delegateBySig", + values: [ + AddressLike, + BigNumberish, + BigNumberish, + BigNumberish, + BytesLike, + BytesLike + ] + ): string; + encodeFunctionData( + functionFragment: "delegates", + values: [AddressLike] + ): string; + encodeFunctionData( + functionFragment: "distributor", + values?: undefined + ): string; + encodeFunctionData(functionFragment: "earned", values: [AddressLike]): string; + encodeFunctionData( + functionFragment: "eip712Domain", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getLockedNftDetails", + values: [AddressLike] + ): string; + encodeFunctionData( + functionFragment: "getPastTotalSupply", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "getPastVotes", + values: [AddressLike, BigNumberish] + ): string; + encodeFunctionData(functionFragment: "getReward", values?: undefined): string; + encodeFunctionData( + functionFragment: "getRewardETH", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getTokenPower", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "getVotes", + values: [AddressLike] + ): string; + encodeFunctionData( + functionFragment: "increaseLockAmount", + values: [BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "increaseLockDuration", + values: [BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "init", + values: [ + AddressLike, + AddressLike, + AddressLike, + BigNumberish, + AddressLike, + AddressLike + ] + ): string; + encodeFunctionData( + functionFragment: "initDelegates", + values: [AddressLike[]] + ): string; + encodeFunctionData( + functionFragment: "lastTimeRewardApplicable", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "lastUpdateTime", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "lockedByToken", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "lockedTokenIdNfts", + values: [AddressLike, BigNumberish] + ): string; + encodeFunctionData(functionFragment: "locker", values?: undefined): string; + encodeFunctionData( + functionFragment: "lpPower", + values: [BigNumberish] + ): string; + encodeFunctionData(functionFragment: "name", values?: undefined): string; + encodeFunctionData(functionFragment: "nonces", values: [AddressLike]): string; + encodeFunctionData( + functionFragment: "notifyRewardAmount", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "numCheckpoints", + values: [AddressLike] + ): string; + encodeFunctionData( + functionFragment: "onERC721Received", + values: [AddressLike, AddressLike, BigNumberish, BytesLike] + ): string; + encodeFunctionData(functionFragment: "owner", values?: undefined): string; + encodeFunctionData( + functionFragment: "periodFinish", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "recoverERC20", + values: [AddressLike, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "renounceOwnership", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "rewardPerToken", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "rewardPerTokenStored", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "rewardRate", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "rewards", + values: [AddressLike] + ): string; + encodeFunctionData( + functionFragment: "rewardsDuration", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "rewardsToken", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "setRewardDistributor", + values: [AddressLike] + ): string; + encodeFunctionData( + functionFragment: "setVotingPowerCombined", + values: [AddressLike] + ): string; + encodeFunctionData(functionFragment: "symbol", values?: undefined): string; + encodeFunctionData( + functionFragment: "tokenPower", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "totalNFTStaked", + values: [AddressLike] + ): string; + encodeFunctionData( + functionFragment: "totalSupply", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "transfer", + values: [AddressLike, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "transferFrom", + values: [AddressLike, AddressLike, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "transferOwnership", + values: [AddressLike] + ): string; + encodeFunctionData( + functionFragment: "unstakeAndWithdraw", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "unstakeToken", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "updateRewardFor", + values: [AddressLike] + ): string; + encodeFunctionData( + functionFragment: "userRewardPerTokenPaid", + values: [AddressLike] + ): string; + encodeFunctionData( + functionFragment: "votingPowerCombined", + values?: undefined + ): string; + + decodeFunctionResult(functionFragment: "CLOCK_MODE", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "__", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "checkpoints", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "clock", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "delegate", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "delegateBySig", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "delegates", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "distributor", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "earned", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "eip712Domain", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getLockedNftDetails", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getPastTotalSupply", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getPastVotes", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "getReward", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "getRewardETH", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getTokenPower", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "getVotes", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "increaseLockAmount", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "increaseLockDuration", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "init", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "initDelegates", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "lastTimeRewardApplicable", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "lastUpdateTime", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "lockedByToken", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "lockedTokenIdNfts", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "locker", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "lpPower", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "name", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "nonces", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "notifyRewardAmount", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "numCheckpoints", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "onERC721Received", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "periodFinish", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "recoverERC20", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "renounceOwnership", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "rewardPerToken", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "rewardPerTokenStored", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "rewardRate", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "rewards", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "rewardsDuration", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "rewardsToken", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "setRewardDistributor", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "setVotingPowerCombined", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "tokenPower", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "totalNFTStaked", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "totalSupply", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "transferFrom", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "transferOwnership", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "unstakeAndWithdraw", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "unstakeToken", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "updateRewardFor", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "userRewardPerTokenPaid", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "votingPowerCombined", + data: BytesLike + ): Result; +} + +export namespace ApprovalEvent { + export type InputTuple = [ + owner: AddressLike, + spender: AddressLike, + value: BigNumberish + ]; + export type OutputTuple = [owner: string, spender: string, value: bigint]; + export interface OutputObject { + owner: string; + spender: string; + value: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace DelegateChangedEvent { + export type InputTuple = [ + delegator: AddressLike, + fromDelegate: AddressLike, + toDelegate: AddressLike + ]; + export type OutputTuple = [ + delegator: string, + fromDelegate: string, + toDelegate: string + ]; + export interface OutputObject { + delegator: string; + fromDelegate: string; + toDelegate: string; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace DelegateVotesChangedEvent { + export type InputTuple = [ + delegate: AddressLike, + previousVotes: BigNumberish, + newVotes: BigNumberish + ]; + export type OutputTuple = [ + delegate: string, + previousVotes: bigint, + newVotes: bigint + ]; + export interface OutputObject { + delegate: string; + previousVotes: bigint; + newVotes: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace EIP712DomainChangedEvent { + export type InputTuple = []; + export type OutputTuple = []; + export interface OutputObject {} + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace InitializedEvent { + export type InputTuple = [version: BigNumberish]; + export type OutputTuple = [version: bigint]; + export interface OutputObject { + version: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace LpOracleSetEvent { + export type InputTuple = [oldLpOracle: AddressLike, newLpOracle: AddressLike]; + export type OutputTuple = [oldLpOracle: string, newLpOracle: string]; + export interface OutputObject { + oldLpOracle: string; + newLpOracle: string; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace OwnershipTransferredEvent { + export type InputTuple = [previousOwner: AddressLike, newOwner: AddressLike]; + export type OutputTuple = [previousOwner: string, newOwner: string]; + export interface OutputObject { + previousOwner: string; + newOwner: string; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace RecoveredEvent { + export type InputTuple = [token: AddressLike, amount: BigNumberish]; + export type OutputTuple = [token: string, amount: bigint]; + export interface OutputObject { + token: string; + amount: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace RewardAddedEvent { + export type InputTuple = [reward: BigNumberish]; + export type OutputTuple = [reward: bigint]; + export interface OutputObject { + reward: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace RewardPaidEvent { + export type InputTuple = [user: AddressLike, reward: BigNumberish]; + export type OutputTuple = [user: string, reward: bigint]; + export interface OutputObject { + user: string; + reward: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace RewardsDurationUpdatedEvent { + export type InputTuple = [newDuration: BigNumberish]; + export type OutputTuple = [newDuration: bigint]; + export interface OutputObject { + newDuration: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace RewardsTokenUpdatedEvent { + export type InputTuple = [ + previousToken: AddressLike, + _zeroToken: AddressLike + ]; + export type OutputTuple = [previousToken: string, _zeroToken: string]; + export interface OutputObject { + previousToken: string; + _zeroToken: string; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace TokenLockerUpdatedEvent { + export type InputTuple = [ + previousLocker: AddressLike, + _tokenLocker: AddressLike + ]; + export type OutputTuple = [previousLocker: string, _tokenLocker: string]; + export interface OutputObject { + previousLocker: string; + _tokenLocker: string; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace TransferEvent { + export type InputTuple = [ + from: AddressLike, + to: AddressLike, + value: BigNumberish + ]; + export type OutputTuple = [from: string, to: string, value: bigint]; + export interface OutputObject { + from: string; + to: string; + value: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace VotingPowerCombinedUpdatedEvent { + export type InputTuple = [ + previousVotingPowerCombined: AddressLike, + _votingPowerCombined: AddressLike + ]; + export type OutputTuple = [ + previousVotingPowerCombined: string, + _votingPowerCombined: string + ]; + export interface OutputObject { + previousVotingPowerCombined: string; + _votingPowerCombined: string; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace ZeroAggregatorSetEvent { + export type InputTuple = [ + oldZeroAggregator: AddressLike, + newZeroAggregator: AddressLike + ]; + export type OutputTuple = [ + oldZeroAggregator: string, + newZeroAggregator: string + ]; + export interface OutputObject { + oldZeroAggregator: string; + newZeroAggregator: string; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export interface Vesting extends BaseContract { + connect(runner?: ContractRunner | null): Vesting; + waitForDeployment(): Promise; + + interface: VestingInterface; + + queryFilter( + event: TCEvent, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>>; + queryFilter( + filter: TypedDeferredTopicFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>>; + + on( + event: TCEvent, + listener: TypedListener + ): Promise; + on( + filter: TypedDeferredTopicFilter, + listener: TypedListener + ): Promise; + + once( + event: TCEvent, + listener: TypedListener + ): Promise; + once( + filter: TypedDeferredTopicFilter, + listener: TypedListener + ): Promise; + + listeners( + event: TCEvent + ): Promise>>; + listeners(eventName?: string): Promise>; + removeAllListeners( + event?: TCEvent + ): Promise; + + CLOCK_MODE: TypedContractMethod<[], [string], "view">; + + __: TypedContractMethod<[], [string], "view">; + + allowance: TypedContractMethod< + [owner: AddressLike, spender: AddressLike], + [bigint], + "view" + >; + + approve: TypedContractMethod< + [spender: AddressLike, value: BigNumberish], + [boolean], + "nonpayable" + >; + + balanceOf: TypedContractMethod<[account: AddressLike], [bigint], "view">; + + checkpoints: TypedContractMethod< + [account: AddressLike, pos: BigNumberish], + [Checkpoints.Checkpoint208StructOutput], + "view" + >; + + clock: TypedContractMethod<[], [bigint], "view">; + + decimals: TypedContractMethod<[], [bigint], "view">; + + delegate: TypedContractMethod<[delegatee: AddressLike], [void], "nonpayable">; + + delegateBySig: TypedContractMethod< + [ + delegatee: AddressLike, + nonce: BigNumberish, + expiry: BigNumberish, + v: BigNumberish, + r: BytesLike, + s: BytesLike + ], + [void], + "nonpayable" + >; + + delegates: TypedContractMethod<[account: AddressLike], [string], "view">; + + distributor: TypedContractMethod<[], [string], "view">; + + earned: TypedContractMethod<[account: AddressLike], [bigint], "view">; + + eip712Domain: TypedContractMethod< + [], + [ + [string, string, string, bigint, string, string, bigint[]] & { + fields: string; + name: string; + version: string; + chainId: bigint; + verifyingContract: string; + salt: string; + extensions: bigint[]; + } + ], + "view" + >; + + getLockedNftDetails: TypedContractMethod< + [_user: AddressLike], + [[bigint[], ILocker.LockedBalanceStructOutput[]]], + "view" + >; + + getPastTotalSupply: TypedContractMethod< + [timepoint: BigNumberish], + [bigint], + "view" + >; + + getPastVotes: TypedContractMethod< + [account: AddressLike, timepoint: BigNumberish], + [bigint], + "view" + >; + + getReward: TypedContractMethod<[], [void], "nonpayable">; + + getRewardETH: TypedContractMethod<[], [void], "nonpayable">; + + getTokenPower: TypedContractMethod<[amount: BigNumberish], [bigint], "view">; + + getVotes: TypedContractMethod<[account: AddressLike], [bigint], "view">; + + increaseLockAmount: TypedContractMethod< + [tokenId: BigNumberish, newLockAmount: BigNumberish], + [void], + "nonpayable" + >; + + increaseLockDuration: TypedContractMethod< + [tokenId: BigNumberish, newLockDuration: BigNumberish], + [void], + "nonpayable" + >; + + init: TypedContractMethod< + [ + _locker: AddressLike, + _zeroToken: AddressLike, + _poolVoter: AddressLike, + _rewardsDuration: BigNumberish, + _owner: AddressLike, + _distributor: AddressLike + ], + [void], + "nonpayable" + >; + + initDelegates: TypedContractMethod< + [who: AddressLike[]], + [void], + "nonpayable" + >; + + lastTimeRewardApplicable: TypedContractMethod<[], [bigint], "view">; + + lastUpdateTime: TypedContractMethod<[], [bigint], "view">; + + lockedByToken: TypedContractMethod<[arg0: BigNumberish], [string], "view">; + + lockedTokenIdNfts: TypedContractMethod< + [arg0: AddressLike, arg1: BigNumberish], + [bigint], + "view" + >; + + locker: TypedContractMethod<[], [string], "view">; + + lpPower: TypedContractMethod<[arg0: BigNumberish], [bigint], "view">; + + name: TypedContractMethod<[], [string], "view">; + + nonces: TypedContractMethod<[owner: AddressLike], [bigint], "view">; + + notifyRewardAmount: TypedContractMethod< + [reward: BigNumberish], + [void], + "nonpayable" + >; + + numCheckpoints: TypedContractMethod<[account: AddressLike], [bigint], "view">; + + onERC721Received: TypedContractMethod< + [ + to: AddressLike, + from: AddressLike, + tokenId: BigNumberish, + data: BytesLike + ], + [string], + "nonpayable" + >; + + owner: TypedContractMethod<[], [string], "view">; + + periodFinish: TypedContractMethod<[], [bigint], "view">; + + recoverERC20: TypedContractMethod< + [tokenAddress: AddressLike, tokenAmount: BigNumberish], + [void], + "nonpayable" + >; + + renounceOwnership: TypedContractMethod<[], [void], "nonpayable">; + + rewardPerToken: TypedContractMethod<[], [bigint], "view">; + + rewardPerTokenStored: TypedContractMethod<[], [bigint], "view">; + + rewardRate: TypedContractMethod<[], [bigint], "view">; + + rewards: TypedContractMethod<[arg0: AddressLike], [bigint], "view">; + + rewardsDuration: TypedContractMethod<[], [bigint], "view">; + + rewardsToken: TypedContractMethod<[], [string], "view">; + + setRewardDistributor: TypedContractMethod< + [what: AddressLike], + [void], + "nonpayable" + >; + + setVotingPowerCombined: TypedContractMethod< + [what: AddressLike], + [void], + "nonpayable" + >; + + symbol: TypedContractMethod<[], [string], "view">; + + tokenPower: TypedContractMethod<[arg0: BigNumberish], [bigint], "view">; + + totalNFTStaked: TypedContractMethod<[who: AddressLike], [bigint], "view">; + + totalSupply: TypedContractMethod<[], [bigint], "view">; + + transfer: TypedContractMethod< + [to: AddressLike, value: BigNumberish], + [boolean], + "nonpayable" + >; + + transferFrom: TypedContractMethod< + [from: AddressLike, to: AddressLike, value: BigNumberish], + [boolean], + "nonpayable" + >; + + transferOwnership: TypedContractMethod< + [newOwner: AddressLike], + [void], + "nonpayable" + >; + + unstakeAndWithdraw: TypedContractMethod< + [tokenId: BigNumberish], + [void], + "nonpayable" + >; + + unstakeToken: TypedContractMethod< + [tokenId: BigNumberish], + [void], + "nonpayable" + >; + + updateRewardFor: TypedContractMethod< + [account: AddressLike], + [void], + "nonpayable" + >; + + userRewardPerTokenPaid: TypedContractMethod< + [arg0: AddressLike], + [bigint], + "view" + >; + + votingPowerCombined: TypedContractMethod<[], [string], "view">; + + getFunction( + key: string | FunctionFragment + ): T; + + getFunction( + nameOrSignature: "CLOCK_MODE" + ): TypedContractMethod<[], [string], "view">; + getFunction(nameOrSignature: "__"): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "allowance" + ): TypedContractMethod< + [owner: AddressLike, spender: AddressLike], + [bigint], + "view" + >; + getFunction( + nameOrSignature: "approve" + ): TypedContractMethod< + [spender: AddressLike, value: BigNumberish], + [boolean], + "nonpayable" + >; + getFunction( + nameOrSignature: "balanceOf" + ): TypedContractMethod<[account: AddressLike], [bigint], "view">; + getFunction( + nameOrSignature: "checkpoints" + ): TypedContractMethod< + [account: AddressLike, pos: BigNumberish], + [Checkpoints.Checkpoint208StructOutput], + "view" + >; + getFunction( + nameOrSignature: "clock" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "decimals" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "delegate" + ): TypedContractMethod<[delegatee: AddressLike], [void], "nonpayable">; + getFunction( + nameOrSignature: "delegateBySig" + ): TypedContractMethod< + [ + delegatee: AddressLike, + nonce: BigNumberish, + expiry: BigNumberish, + v: BigNumberish, + r: BytesLike, + s: BytesLike + ], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "delegates" + ): TypedContractMethod<[account: AddressLike], [string], "view">; + getFunction( + nameOrSignature: "distributor" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "earned" + ): TypedContractMethod<[account: AddressLike], [bigint], "view">; + getFunction( + nameOrSignature: "eip712Domain" + ): TypedContractMethod< + [], + [ + [string, string, string, bigint, string, string, bigint[]] & { + fields: string; + name: string; + version: string; + chainId: bigint; + verifyingContract: string; + salt: string; + extensions: bigint[]; + } + ], + "view" + >; + getFunction( + nameOrSignature: "getLockedNftDetails" + ): TypedContractMethod< + [_user: AddressLike], + [[bigint[], ILocker.LockedBalanceStructOutput[]]], + "view" + >; + getFunction( + nameOrSignature: "getPastTotalSupply" + ): TypedContractMethod<[timepoint: BigNumberish], [bigint], "view">; + getFunction( + nameOrSignature: "getPastVotes" + ): TypedContractMethod< + [account: AddressLike, timepoint: BigNumberish], + [bigint], + "view" + >; + getFunction( + nameOrSignature: "getReward" + ): TypedContractMethod<[], [void], "nonpayable">; + getFunction( + nameOrSignature: "getRewardETH" + ): TypedContractMethod<[], [void], "nonpayable">; + getFunction( + nameOrSignature: "getTokenPower" + ): TypedContractMethod<[amount: BigNumberish], [bigint], "view">; + getFunction( + nameOrSignature: "getVotes" + ): TypedContractMethod<[account: AddressLike], [bigint], "view">; + getFunction( + nameOrSignature: "increaseLockAmount" + ): TypedContractMethod< + [tokenId: BigNumberish, newLockAmount: BigNumberish], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "increaseLockDuration" + ): TypedContractMethod< + [tokenId: BigNumberish, newLockDuration: BigNumberish], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "init" + ): TypedContractMethod< + [ + _locker: AddressLike, + _zeroToken: AddressLike, + _poolVoter: AddressLike, + _rewardsDuration: BigNumberish, + _owner: AddressLike, + _distributor: AddressLike + ], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "initDelegates" + ): TypedContractMethod<[who: AddressLike[]], [void], "nonpayable">; + getFunction( + nameOrSignature: "lastTimeRewardApplicable" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "lastUpdateTime" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "lockedByToken" + ): TypedContractMethod<[arg0: BigNumberish], [string], "view">; + getFunction( + nameOrSignature: "lockedTokenIdNfts" + ): TypedContractMethod< + [arg0: AddressLike, arg1: BigNumberish], + [bigint], + "view" + >; + getFunction( + nameOrSignature: "locker" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "lpPower" + ): TypedContractMethod<[arg0: BigNumberish], [bigint], "view">; + getFunction( + nameOrSignature: "name" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "nonces" + ): TypedContractMethod<[owner: AddressLike], [bigint], "view">; + getFunction( + nameOrSignature: "notifyRewardAmount" + ): TypedContractMethod<[reward: BigNumberish], [void], "nonpayable">; + getFunction( + nameOrSignature: "numCheckpoints" + ): TypedContractMethod<[account: AddressLike], [bigint], "view">; + getFunction( + nameOrSignature: "onERC721Received" + ): TypedContractMethod< + [ + to: AddressLike, + from: AddressLike, + tokenId: BigNumberish, + data: BytesLike + ], + [string], + "nonpayable" + >; + getFunction( + nameOrSignature: "owner" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "periodFinish" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "recoverERC20" + ): TypedContractMethod< + [tokenAddress: AddressLike, tokenAmount: BigNumberish], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "renounceOwnership" + ): TypedContractMethod<[], [void], "nonpayable">; + getFunction( + nameOrSignature: "rewardPerToken" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "rewardPerTokenStored" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "rewardRate" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "rewards" + ): TypedContractMethod<[arg0: AddressLike], [bigint], "view">; + getFunction( + nameOrSignature: "rewardsDuration" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "rewardsToken" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "setRewardDistributor" + ): TypedContractMethod<[what: AddressLike], [void], "nonpayable">; + getFunction( + nameOrSignature: "setVotingPowerCombined" + ): TypedContractMethod<[what: AddressLike], [void], "nonpayable">; + getFunction( + nameOrSignature: "symbol" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "tokenPower" + ): TypedContractMethod<[arg0: BigNumberish], [bigint], "view">; + getFunction( + nameOrSignature: "totalNFTStaked" + ): TypedContractMethod<[who: AddressLike], [bigint], "view">; + getFunction( + nameOrSignature: "totalSupply" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "transfer" + ): TypedContractMethod< + [to: AddressLike, value: BigNumberish], + [boolean], + "nonpayable" + >; + getFunction( + nameOrSignature: "transferFrom" + ): TypedContractMethod< + [from: AddressLike, to: AddressLike, value: BigNumberish], + [boolean], + "nonpayable" + >; + getFunction( + nameOrSignature: "transferOwnership" + ): TypedContractMethod<[newOwner: AddressLike], [void], "nonpayable">; + getFunction( + nameOrSignature: "unstakeAndWithdraw" + ): TypedContractMethod<[tokenId: BigNumberish], [void], "nonpayable">; + getFunction( + nameOrSignature: "unstakeToken" + ): TypedContractMethod<[tokenId: BigNumberish], [void], "nonpayable">; + getFunction( + nameOrSignature: "updateRewardFor" + ): TypedContractMethod<[account: AddressLike], [void], "nonpayable">; + getFunction( + nameOrSignature: "userRewardPerTokenPaid" + ): TypedContractMethod<[arg0: AddressLike], [bigint], "view">; + getFunction( + nameOrSignature: "votingPowerCombined" + ): TypedContractMethod<[], [string], "view">; + + getEvent( + key: "Approval" + ): TypedContractEvent< + ApprovalEvent.InputTuple, + ApprovalEvent.OutputTuple, + ApprovalEvent.OutputObject + >; + getEvent( + key: "DelegateChanged" + ): TypedContractEvent< + DelegateChangedEvent.InputTuple, + DelegateChangedEvent.OutputTuple, + DelegateChangedEvent.OutputObject + >; + getEvent( + key: "DelegateVotesChanged" + ): TypedContractEvent< + DelegateVotesChangedEvent.InputTuple, + DelegateVotesChangedEvent.OutputTuple, + DelegateVotesChangedEvent.OutputObject + >; + getEvent( + key: "EIP712DomainChanged" + ): TypedContractEvent< + EIP712DomainChangedEvent.InputTuple, + EIP712DomainChangedEvent.OutputTuple, + EIP712DomainChangedEvent.OutputObject + >; + getEvent( + key: "Initialized" + ): TypedContractEvent< + InitializedEvent.InputTuple, + InitializedEvent.OutputTuple, + InitializedEvent.OutputObject + >; + getEvent( + key: "LpOracleSet" + ): TypedContractEvent< + LpOracleSetEvent.InputTuple, + LpOracleSetEvent.OutputTuple, + LpOracleSetEvent.OutputObject + >; + getEvent( + key: "OwnershipTransferred" + ): TypedContractEvent< + OwnershipTransferredEvent.InputTuple, + OwnershipTransferredEvent.OutputTuple, + OwnershipTransferredEvent.OutputObject + >; + getEvent( + key: "Recovered" + ): TypedContractEvent< + RecoveredEvent.InputTuple, + RecoveredEvent.OutputTuple, + RecoveredEvent.OutputObject + >; + getEvent( + key: "RewardAdded" + ): TypedContractEvent< + RewardAddedEvent.InputTuple, + RewardAddedEvent.OutputTuple, + RewardAddedEvent.OutputObject + >; + getEvent( + key: "RewardPaid" + ): TypedContractEvent< + RewardPaidEvent.InputTuple, + RewardPaidEvent.OutputTuple, + RewardPaidEvent.OutputObject + >; + getEvent( + key: "RewardsDurationUpdated" + ): TypedContractEvent< + RewardsDurationUpdatedEvent.InputTuple, + RewardsDurationUpdatedEvent.OutputTuple, + RewardsDurationUpdatedEvent.OutputObject + >; + getEvent( + key: "RewardsTokenUpdated" + ): TypedContractEvent< + RewardsTokenUpdatedEvent.InputTuple, + RewardsTokenUpdatedEvent.OutputTuple, + RewardsTokenUpdatedEvent.OutputObject + >; + getEvent( + key: "TokenLockerUpdated" + ): TypedContractEvent< + TokenLockerUpdatedEvent.InputTuple, + TokenLockerUpdatedEvent.OutputTuple, + TokenLockerUpdatedEvent.OutputObject + >; + getEvent( + key: "Transfer" + ): TypedContractEvent< + TransferEvent.InputTuple, + TransferEvent.OutputTuple, + TransferEvent.OutputObject + >; + getEvent( + key: "VotingPowerCombinedUpdated" + ): TypedContractEvent< + VotingPowerCombinedUpdatedEvent.InputTuple, + VotingPowerCombinedUpdatedEvent.OutputTuple, + VotingPowerCombinedUpdatedEvent.OutputObject + >; + getEvent( + key: "ZeroAggregatorSet" + ): TypedContractEvent< + ZeroAggregatorSetEvent.InputTuple, + ZeroAggregatorSetEvent.OutputTuple, + ZeroAggregatorSetEvent.OutputObject + >; + + filters: { + "Approval(address,address,uint256)": TypedContractEvent< + ApprovalEvent.InputTuple, + ApprovalEvent.OutputTuple, + ApprovalEvent.OutputObject + >; + Approval: TypedContractEvent< + ApprovalEvent.InputTuple, + ApprovalEvent.OutputTuple, + ApprovalEvent.OutputObject + >; + + "DelegateChanged(address,address,address)": TypedContractEvent< + DelegateChangedEvent.InputTuple, + DelegateChangedEvent.OutputTuple, + DelegateChangedEvent.OutputObject + >; + DelegateChanged: TypedContractEvent< + DelegateChangedEvent.InputTuple, + DelegateChangedEvent.OutputTuple, + DelegateChangedEvent.OutputObject + >; + + "DelegateVotesChanged(address,uint256,uint256)": TypedContractEvent< + DelegateVotesChangedEvent.InputTuple, + DelegateVotesChangedEvent.OutputTuple, + DelegateVotesChangedEvent.OutputObject + >; + DelegateVotesChanged: TypedContractEvent< + DelegateVotesChangedEvent.InputTuple, + DelegateVotesChangedEvent.OutputTuple, + DelegateVotesChangedEvent.OutputObject + >; + + "EIP712DomainChanged()": TypedContractEvent< + EIP712DomainChangedEvent.InputTuple, + EIP712DomainChangedEvent.OutputTuple, + EIP712DomainChangedEvent.OutputObject + >; + EIP712DomainChanged: TypedContractEvent< + EIP712DomainChangedEvent.InputTuple, + EIP712DomainChangedEvent.OutputTuple, + EIP712DomainChangedEvent.OutputObject + >; + + "Initialized(uint64)": TypedContractEvent< + InitializedEvent.InputTuple, + InitializedEvent.OutputTuple, + InitializedEvent.OutputObject + >; + Initialized: TypedContractEvent< + InitializedEvent.InputTuple, + InitializedEvent.OutputTuple, + InitializedEvent.OutputObject + >; + + "LpOracleSet(address,address)": TypedContractEvent< + LpOracleSetEvent.InputTuple, + LpOracleSetEvent.OutputTuple, + LpOracleSetEvent.OutputObject + >; + LpOracleSet: TypedContractEvent< + LpOracleSetEvent.InputTuple, + LpOracleSetEvent.OutputTuple, + LpOracleSetEvent.OutputObject + >; + + "OwnershipTransferred(address,address)": TypedContractEvent< + OwnershipTransferredEvent.InputTuple, + OwnershipTransferredEvent.OutputTuple, + OwnershipTransferredEvent.OutputObject + >; + OwnershipTransferred: TypedContractEvent< + OwnershipTransferredEvent.InputTuple, + OwnershipTransferredEvent.OutputTuple, + OwnershipTransferredEvent.OutputObject + >; + + "Recovered(address,uint256)": TypedContractEvent< + RecoveredEvent.InputTuple, + RecoveredEvent.OutputTuple, + RecoveredEvent.OutputObject + >; + Recovered: TypedContractEvent< + RecoveredEvent.InputTuple, + RecoveredEvent.OutputTuple, + RecoveredEvent.OutputObject + >; + + "RewardAdded(uint256)": TypedContractEvent< + RewardAddedEvent.InputTuple, + RewardAddedEvent.OutputTuple, + RewardAddedEvent.OutputObject + >; + RewardAdded: TypedContractEvent< + RewardAddedEvent.InputTuple, + RewardAddedEvent.OutputTuple, + RewardAddedEvent.OutputObject + >; + + "RewardPaid(address,uint256)": TypedContractEvent< + RewardPaidEvent.InputTuple, + RewardPaidEvent.OutputTuple, + RewardPaidEvent.OutputObject + >; + RewardPaid: TypedContractEvent< + RewardPaidEvent.InputTuple, + RewardPaidEvent.OutputTuple, + RewardPaidEvent.OutputObject + >; + + "RewardsDurationUpdated(uint256)": TypedContractEvent< + RewardsDurationUpdatedEvent.InputTuple, + RewardsDurationUpdatedEvent.OutputTuple, + RewardsDurationUpdatedEvent.OutputObject + >; + RewardsDurationUpdated: TypedContractEvent< + RewardsDurationUpdatedEvent.InputTuple, + RewardsDurationUpdatedEvent.OutputTuple, + RewardsDurationUpdatedEvent.OutputObject + >; + + "RewardsTokenUpdated(address,address)": TypedContractEvent< + RewardsTokenUpdatedEvent.InputTuple, + RewardsTokenUpdatedEvent.OutputTuple, + RewardsTokenUpdatedEvent.OutputObject + >; + RewardsTokenUpdated: TypedContractEvent< + RewardsTokenUpdatedEvent.InputTuple, + RewardsTokenUpdatedEvent.OutputTuple, + RewardsTokenUpdatedEvent.OutputObject + >; + + "TokenLockerUpdated(address,address)": TypedContractEvent< + TokenLockerUpdatedEvent.InputTuple, + TokenLockerUpdatedEvent.OutputTuple, + TokenLockerUpdatedEvent.OutputObject + >; + TokenLockerUpdated: TypedContractEvent< + TokenLockerUpdatedEvent.InputTuple, + TokenLockerUpdatedEvent.OutputTuple, + TokenLockerUpdatedEvent.OutputObject + >; + + "Transfer(address,address,uint256)": TypedContractEvent< + TransferEvent.InputTuple, + TransferEvent.OutputTuple, + TransferEvent.OutputObject + >; + Transfer: TypedContractEvent< + TransferEvent.InputTuple, + TransferEvent.OutputTuple, + TransferEvent.OutputObject + >; + + "VotingPowerCombinedUpdated(address,address)": TypedContractEvent< + VotingPowerCombinedUpdatedEvent.InputTuple, + VotingPowerCombinedUpdatedEvent.OutputTuple, + VotingPowerCombinedUpdatedEvent.OutputObject + >; + VotingPowerCombinedUpdated: TypedContractEvent< + VotingPowerCombinedUpdatedEvent.InputTuple, + VotingPowerCombinedUpdatedEvent.OutputTuple, + VotingPowerCombinedUpdatedEvent.OutputObject + >; + + "ZeroAggregatorSet(address,address)": TypedContractEvent< + ZeroAggregatorSetEvent.InputTuple, + ZeroAggregatorSetEvent.OutputTuple, + ZeroAggregatorSetEvent.OutputObject + >; + ZeroAggregatorSet: TypedContractEvent< + ZeroAggregatorSetEvent.InputTuple, + ZeroAggregatorSetEvent.OutputTuple, + ZeroAggregatorSetEvent.OutputObject + >; + }; +} diff --git a/packages/adapters-library/src/adapters/zerolend/contracts/abis/vesting.json b/packages/adapters-library/src/adapters/zerolend/contracts/abis/vesting.json new file mode 100644 index 000000000..cbbcac725 --- /dev/null +++ b/packages/adapters-library/src/adapters/zerolend/contracts/abis/vesting.json @@ -0,0 +1 @@ +[{"inputs":[],"name":"CheckpointUnorderedInsertion","type":"error"},{"inputs":[],"name":"ECDSAInvalidSignature","type":"error"},{"inputs":[{"internalType":"uint256","name":"length","type":"uint256"}],"name":"ECDSAInvalidSignatureLength","type":"error"},{"inputs":[{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"ECDSAInvalidSignatureS","type":"error"},{"inputs":[{"internalType":"uint256","name":"increasedSupply","type":"uint256"},{"internalType":"uint256","name":"cap","type":"uint256"}],"name":"ERC20ExceededSafeSupply","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[{"internalType":"uint256","name":"timepoint","type":"uint256"},{"internalType":"uint48","name":"clock","type":"uint48"}],"name":"ERC5805FutureLookup","type":"error"},{"inputs":[],"name":"ERC6372InconsistentClock","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"currentNonce","type":"uint256"}],"name":"InvalidAccountNonce","type":"error"},{"inputs":[],"name":"InvalidInitialization","type":"error"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"InvalidUnstaker","type":"error"},{"inputs":[],"name":"NotInitializing","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[{"internalType":"uint8","name":"bits","type":"uint8"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"SafeCastOverflowedUintDowncast","type":"error"},{"inputs":[{"internalType":"uint256","name":"expiry","type":"uint256"}],"name":"VotesExpiredSignature","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegator","type":"address"},{"indexed":true,"internalType":"address","name":"fromDelegate","type":"address"},{"indexed":true,"internalType":"address","name":"toDelegate","type":"address"}],"name":"DelegateChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousVotes","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newVotes","type":"uint256"}],"name":"DelegateVotesChanged","type":"event"},{"anonymous":false,"inputs":[],"name":"EIP712DomainChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"version","type":"uint64"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldLpOracle","type":"address"},{"indexed":true,"internalType":"address","name":"newLpOracle","type":"address"}],"name":"LpOracleSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Recovered","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newDuration","type":"uint256"}],"name":"RewardsDurationUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"previousToken","type":"address"},{"indexed":false,"internalType":"address","name":"_zeroToken","type":"address"}],"name":"RewardsTokenUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"previousLocker","type":"address"},{"indexed":false,"internalType":"address","name":"_tokenLocker","type":"address"}],"name":"TokenLockerUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"previousVotingPowerCombined","type":"address"},{"indexed":false,"internalType":"address","name":"_votingPowerCombined","type":"address"}],"name":"VotingPowerCombinedUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldZeroAggregator","type":"address"},{"indexed":true,"internalType":"address","name":"newZeroAggregator","type":"address"}],"name":"ZeroAggregatorSet","type":"event"},{"inputs":[],"name":"CLOCK_MODE","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"__","outputs":[{"internalType":"contract ILocker","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint32","name":"pos","type":"uint32"}],"name":"checkpoints","outputs":[{"components":[{"internalType":"uint48","name":"_key","type":"uint48"},{"internalType":"uint208","name":"_value","type":"uint208"}],"internalType":"struct Checkpoints.Checkpoint208","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"clock","outputs":[{"internalType":"uint48","name":"","type":"uint48"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"}],"name":"delegate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"delegateBySig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"delegates","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"distributor","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"earned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"getLockedNftDetails","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"},{"components":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"end","type":"uint256"},{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"power","type":"uint256"}],"internalType":"struct ILocker.LockedBalance[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"timepoint","type":"uint256"}],"name":"getPastTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"timepoint","type":"uint256"}],"name":"getPastVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getRewardETH","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"getTokenPower","outputs":[{"internalType":"uint256","name":"power","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"newLockAmount","type":"uint256"}],"name":"increaseLockAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"newLockDuration","type":"uint256"}],"name":"increaseLockDuration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_locker","type":"address"},{"internalType":"address","name":"_zeroToken","type":"address"},{"internalType":"address","name":"_poolVoter","type":"address"},{"internalType":"uint256","name":"_rewardsDuration","type":"uint256"},{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_distributor","type":"address"}],"name":"init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"who","type":"address[]"}],"name":"initDelegates","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"lastTimeRewardApplicable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastUpdateTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"lockedByToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"lockedTokenIdNfts","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"locker","outputs":[{"internalType":"contract ILocker","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"lpPower","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"reward","type":"uint256"}],"name":"notifyRewardAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"numCheckpoints","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"periodFinish","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"tokenAmount","type":"uint256"}],"name":"recoverERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardPerToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerTokenStored","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardsDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardsToken","outputs":[{"internalType":"contract IZeroLend","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"what","type":"address"}],"name":"setRewardDistributor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"what","type":"address"}],"name":"setVotingPowerCombined","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"tokenPower","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"who","type":"address"}],"name":"totalNFTStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"unstakeAndWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"unstakeToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"updateRewardFor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userRewardPerTokenPaid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"votingPowerCombined","outputs":[{"internalType":"contract IVotingPowerCombined","name":"","type":"address"}],"stateMutability":"view","type":"function"}] \ No newline at end of file diff --git a/packages/adapters-library/src/adapters/zerolend/contracts/factories/Vesting__factory.ts b/packages/adapters-library/src/adapters/zerolend/contracts/factories/Vesting__factory.ts new file mode 100644 index 000000000..b0360362d --- /dev/null +++ b/packages/adapters-library/src/adapters/zerolend/contracts/factories/Vesting__factory.ts @@ -0,0 +1,1656 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Interface, type ContractRunner } from "ethers"; +import type { Vesting, VestingInterface } from "../Vesting"; + +const _abi = [ + { + inputs: [], + name: "CheckpointUnorderedInsertion", + type: "error", + }, + { + inputs: [], + name: "ECDSAInvalidSignature", + type: "error", + }, + { + inputs: [ + { + internalType: "uint256", + name: "length", + type: "uint256", + }, + ], + name: "ECDSAInvalidSignatureLength", + type: "error", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "s", + type: "bytes32", + }, + ], + name: "ECDSAInvalidSignatureS", + type: "error", + }, + { + inputs: [ + { + internalType: "uint256", + name: "increasedSupply", + type: "uint256", + }, + { + internalType: "uint256", + name: "cap", + type: "uint256", + }, + ], + name: "ERC20ExceededSafeSupply", + type: "error", + }, + { + inputs: [ + { + internalType: "address", + name: "spender", + type: "address", + }, + { + internalType: "uint256", + name: "allowance", + type: "uint256", + }, + { + internalType: "uint256", + name: "needed", + type: "uint256", + }, + ], + name: "ERC20InsufficientAllowance", + type: "error", + }, + { + inputs: [ + { + internalType: "address", + name: "sender", + type: "address", + }, + { + internalType: "uint256", + name: "balance", + type: "uint256", + }, + { + internalType: "uint256", + name: "needed", + type: "uint256", + }, + ], + name: "ERC20InsufficientBalance", + type: "error", + }, + { + inputs: [ + { + internalType: "address", + name: "approver", + type: "address", + }, + ], + name: "ERC20InvalidApprover", + type: "error", + }, + { + inputs: [ + { + internalType: "address", + name: "receiver", + type: "address", + }, + ], + name: "ERC20InvalidReceiver", + type: "error", + }, + { + inputs: [ + { + internalType: "address", + name: "sender", + type: "address", + }, + ], + name: "ERC20InvalidSender", + type: "error", + }, + { + inputs: [ + { + internalType: "address", + name: "spender", + type: "address", + }, + ], + name: "ERC20InvalidSpender", + type: "error", + }, + { + inputs: [ + { + internalType: "uint256", + name: "timepoint", + type: "uint256", + }, + { + internalType: "uint48", + name: "clock", + type: "uint48", + }, + ], + name: "ERC5805FutureLookup", + type: "error", + }, + { + inputs: [], + name: "ERC6372InconsistentClock", + type: "error", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + { + internalType: "uint256", + name: "currentNonce", + type: "uint256", + }, + ], + name: "InvalidAccountNonce", + type: "error", + }, + { + inputs: [], + name: "InvalidInitialization", + type: "error", + }, + { + inputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + { + internalType: "address", + name: "", + type: "address", + }, + ], + name: "InvalidUnstaker", + type: "error", + }, + { + inputs: [], + name: "NotInitializing", + type: "error", + }, + { + inputs: [ + { + internalType: "address", + name: "owner", + type: "address", + }, + ], + name: "OwnableInvalidOwner", + type: "error", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "OwnableUnauthorizedAccount", + type: "error", + }, + { + inputs: [], + name: "ReentrancyGuardReentrantCall", + type: "error", + }, + { + inputs: [ + { + internalType: "uint8", + name: "bits", + type: "uint8", + }, + { + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "SafeCastOverflowedUintDowncast", + type: "error", + }, + { + inputs: [ + { + internalType: "uint256", + name: "expiry", + type: "uint256", + }, + ], + name: "VotesExpiredSignature", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "owner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "spender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "Approval", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "delegator", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "fromDelegate", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "toDelegate", + type: "address", + }, + ], + name: "DelegateChanged", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "delegate", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "previousVotes", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "newVotes", + type: "uint256", + }, + ], + name: "DelegateVotesChanged", + type: "event", + }, + { + anonymous: false, + inputs: [], + name: "EIP712DomainChanged", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint64", + name: "version", + type: "uint64", + }, + ], + name: "Initialized", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "oldLpOracle", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "newLpOracle", + type: "address", + }, + ], + name: "LpOracleSet", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "previousOwner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "OwnershipTransferred", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "Recovered", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "reward", + type: "uint256", + }, + ], + name: "RewardAdded", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "user", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "reward", + type: "uint256", + }, + ], + name: "RewardPaid", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "newDuration", + type: "uint256", + }, + ], + name: "RewardsDurationUpdated", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "previousToken", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "_zeroToken", + type: "address", + }, + ], + name: "RewardsTokenUpdated", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "previousLocker", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "_tokenLocker", + type: "address", + }, + ], + name: "TokenLockerUpdated", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "from", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "Transfer", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "previousVotingPowerCombined", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "_votingPowerCombined", + type: "address", + }, + ], + name: "VotingPowerCombinedUpdated", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "oldZeroAggregator", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "newZeroAggregator", + type: "address", + }, + ], + name: "ZeroAggregatorSet", + type: "event", + }, + { + inputs: [], + name: "CLOCK_MODE", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "__", + outputs: [ + { + internalType: "contract ILocker", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "owner", + type: "address", + }, + { + internalType: "address", + name: "spender", + type: "address", + }, + ], + name: "allowance", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "spender", + type: "address", + }, + { + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "approve", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "balanceOf", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + { + internalType: "uint32", + name: "pos", + type: "uint32", + }, + ], + name: "checkpoints", + outputs: [ + { + components: [ + { + internalType: "uint48", + name: "_key", + type: "uint48", + }, + { + internalType: "uint208", + name: "_value", + type: "uint208", + }, + ], + internalType: "struct Checkpoints.Checkpoint208", + name: "", + type: "tuple", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "clock", + outputs: [ + { + internalType: "uint48", + name: "", + type: "uint48", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "decimals", + outputs: [ + { + internalType: "uint8", + name: "", + type: "uint8", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "delegatee", + type: "address", + }, + ], + name: "delegate", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "delegatee", + type: "address", + }, + { + internalType: "uint256", + name: "nonce", + type: "uint256", + }, + { + internalType: "uint256", + name: "expiry", + type: "uint256", + }, + { + internalType: "uint8", + name: "v", + type: "uint8", + }, + { + internalType: "bytes32", + name: "r", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "s", + type: "bytes32", + }, + ], + name: "delegateBySig", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "delegates", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "distributor", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "earned", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "eip712Domain", + outputs: [ + { + internalType: "bytes1", + name: "fields", + type: "bytes1", + }, + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "version", + type: "string", + }, + { + internalType: "uint256", + name: "chainId", + type: "uint256", + }, + { + internalType: "address", + name: "verifyingContract", + type: "address", + }, + { + internalType: "bytes32", + name: "salt", + type: "bytes32", + }, + { + internalType: "uint256[]", + name: "extensions", + type: "uint256[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_user", + type: "address", + }, + ], + name: "getLockedNftDetails", + outputs: [ + { + internalType: "uint256[]", + name: "", + type: "uint256[]", + }, + { + components: [ + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "uint256", + name: "end", + type: "uint256", + }, + { + internalType: "uint256", + name: "start", + type: "uint256", + }, + { + internalType: "uint256", + name: "power", + type: "uint256", + }, + ], + internalType: "struct ILocker.LockedBalance[]", + name: "", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "timepoint", + type: "uint256", + }, + ], + name: "getPastTotalSupply", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + { + internalType: "uint256", + name: "timepoint", + type: "uint256", + }, + ], + name: "getPastVotes", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "getReward", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "getRewardETH", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "getTokenPower", + outputs: [ + { + internalType: "uint256", + name: "power", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "getVotes", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + { + internalType: "uint256", + name: "newLockAmount", + type: "uint256", + }, + ], + name: "increaseLockAmount", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + { + internalType: "uint256", + name: "newLockDuration", + type: "uint256", + }, + ], + name: "increaseLockDuration", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_locker", + type: "address", + }, + { + internalType: "address", + name: "_zeroToken", + type: "address", + }, + { + internalType: "address", + name: "_poolVoter", + type: "address", + }, + { + internalType: "uint256", + name: "_rewardsDuration", + type: "uint256", + }, + { + internalType: "address", + name: "_owner", + type: "address", + }, + { + internalType: "address", + name: "_distributor", + type: "address", + }, + ], + name: "init", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address[]", + name: "who", + type: "address[]", + }, + ], + name: "initDelegates", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "lastTimeRewardApplicable", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "lastUpdateTime", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + name: "lockedByToken", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + name: "lockedTokenIdNfts", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "locker", + outputs: [ + { + internalType: "contract ILocker", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + name: "lpPower", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "name", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "owner", + type: "address", + }, + ], + name: "nonces", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "reward", + type: "uint256", + }, + ], + name: "notifyRewardAmount", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "numCheckpoints", + outputs: [ + { + internalType: "uint32", + name: "", + type: "uint32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "address", + name: "from", + type: "address", + }, + { + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "onERC721Received", + outputs: [ + { + internalType: "bytes4", + name: "", + type: "bytes4", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "owner", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "periodFinish", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "tokenAddress", + type: "address", + }, + { + internalType: "uint256", + name: "tokenAmount", + type: "uint256", + }, + ], + name: "recoverERC20", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "renounceOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "rewardPerToken", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "rewardPerTokenStored", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "rewardRate", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + name: "rewards", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "rewardsDuration", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "rewardsToken", + outputs: [ + { + internalType: "contract IZeroLend", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "what", + type: "address", + }, + ], + name: "setRewardDistributor", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "what", + type: "address", + }, + ], + name: "setVotingPowerCombined", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "symbol", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + name: "tokenPower", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "who", + type: "address", + }, + ], + name: "totalNFTStaked", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "totalSupply", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "transfer", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "from", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "transferFrom", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "transferOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + ], + name: "unstakeAndWithdraw", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + ], + name: "unstakeToken", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "updateRewardFor", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + name: "userRewardPerTokenPaid", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "votingPowerCombined", + outputs: [ + { + internalType: "contract IVotingPowerCombined", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, +] as const; + +export class Vesting__factory { + static readonly abi = _abi; + static createInterface(): VestingInterface { + return new Interface(_abi) as VestingInterface; + } + static connect(address: string, runner?: ContractRunner | null): Vesting { + return new Contract(address, _abi, runner) as unknown as Vesting; + } +} diff --git a/packages/adapters-library/src/adapters/zerolend/contracts/factories/index.ts b/packages/adapters-library/src/adapters/zerolend/contracts/factories/index.ts index 36bd46b95..3add5920b 100644 --- a/packages/adapters-library/src/adapters/zerolend/contracts/factories/index.ts +++ b/packages/adapters-library/src/adapters/zerolend/contracts/factories/index.ts @@ -3,3 +3,4 @@ /* eslint-disable */ export { PoolContract__factory } from "./PoolContract__factory"; export { ProtocolDataProvider__factory } from "./ProtocolDataProvider__factory"; +export { Vesting__factory } from "./Vesting__factory"; diff --git a/packages/adapters-library/src/adapters/zerolend/contracts/index.ts b/packages/adapters-library/src/adapters/zerolend/contracts/index.ts index 09be725ef..83fc5ef86 100644 --- a/packages/adapters-library/src/adapters/zerolend/contracts/index.ts +++ b/packages/adapters-library/src/adapters/zerolend/contracts/index.ts @@ -3,6 +3,8 @@ /* eslint-disable */ export type { PoolContract } from "./PoolContract"; export type { ProtocolDataProvider } from "./ProtocolDataProvider"; +export type { Vesting } from "./Vesting"; export * as factories from "./factories"; export { PoolContract__factory } from "./factories/PoolContract__factory"; export { ProtocolDataProvider__factory } from "./factories/ProtocolDataProvider__factory"; +export { Vesting__factory } from "./factories/Vesting__factory"; diff --git a/packages/adapters-library/src/adapters/zerolend/products/a-token/tests/snapshots/ethereum.profits.json b/packages/adapters-library/src/adapters/zerolend/products/a-token/tests/snapshots/ethereum.profits.json index ecc2c9028..2b1f5c588 100644 --- a/packages/adapters-library/src/adapters/zerolend/products/a-token/tests/snapshots/ethereum.profits.json +++ b/packages/adapters-library/src/adapters/zerolend/products/a-token/tests/snapshots/ethereum.profits.json @@ -56,12 +56,12 @@ "9e4c90ff586f34171ab76e7f0e14cdd3": { "result": "0x0000000000000000000000000000000000000000000000000e1b74ab18a31eeb" }, - "3b159c531a8bad1eca9af3e2319d39f5": { - "result": "0x0000000000000000000000000000000000000000000000000e1b3ec40d858fcf" - }, "ccb9e6991c74731a168f743f9b2e6318": { "result": "0x00000000000000000000000000000000000000000000000700000000000001780000000000000000000000000000000000000000000000000000003c7eeb26240000000000000000000000000000000000000000000000000000000066fa79dd0000000000000000000000000000000000000000000000000000000066fa79f30000000000000000000000000000000000000000000000070000000000000178" }, + "3b159c531a8bad1eca9af3e2319d39f5": { + "result": "0x0000000000000000000000000000000000000000000000000e1b3ec40d858fcf" + }, "49b353df32d6f46391788b09024cd206": { "result": "0x000000000000000000000000000000000000000000000007000000000000015a0000000000000000000000000000000000000000000000000000003db03b8ec00000000000000000000000000000000000000000000000000000000066f9239f0000000000000000000000000000000000000000000000000000000066f923b7000000000000000000000000000000000000000000000007000000000000015a" }, diff --git a/packages/adapters-library/src/adapters/zerolend/products/a-token/tests/snapshots/ethereum.tvl.json b/packages/adapters-library/src/adapters/zerolend/products/a-token/tests/snapshots/ethereum.tvl.json index f6e6fd4c2..13901c762 100644 --- a/packages/adapters-library/src/adapters/zerolend/products/a-token/tests/snapshots/ethereum.tvl.json +++ b/packages/adapters-library/src/adapters/zerolend/products/a-token/tests/snapshots/ethereum.tvl.json @@ -40,12 +40,12 @@ } ], "rpcResponses": { - "8e39313b98ca53f7e1e8c0569783d82e": { - "result": "0x000000000000000000000000000000000000000000000048509ff562ed56bca9" - }, "cdc56fcb437f78d294f1bbaf9e6879ee": { "result": "0x00000000000000000000000000000000000000000000000db1f634a6366680eb" }, + "8e39313b98ca53f7e1e8c0569783d82e": { + "result": "0x000000000000000000000000000000000000000000000048509ff562ed56bca9" + }, "24d793af4a3b4dbfa42af9ea469dae5c": { "result": "0x000000000000000000000000000000000000000000000006000000000000410300000000000000000000000000000000000000000000000000000047a07992c000000000000000000000000000000000000000000000000000000000663a24c700000000000000000000000000000000000000000000000000000000663a24c70000000000000000000000000000000000000000000000060000000000004103" } diff --git a/packages/adapters-library/src/adapters/zerolend/products/vesting/tests/snapshots/linea.positions.vesting-2.json b/packages/adapters-library/src/adapters/zerolend/products/vesting/tests/snapshots/linea.positions.vesting-2.json new file mode 100644 index 000000000..1b6fc767a --- /dev/null +++ b/packages/adapters-library/src/adapters/zerolend/products/vesting/tests/snapshots/linea.positions.vesting-2.json @@ -0,0 +1,60 @@ +{ + "blockNumber": 12844441, + "latency": "Latency: 0.419 seconds", + "aggregatedValues": [], + "snapshot": [ + { + "protocolId": "zerolend", + "name": "Zerolend", + "description": "Zerolend defi adapter", + "siteUrl": "", + "iconUrl": "", + "positionType": "stake", + "chainId": 59144, + "productId": "vesting", + "chainName": "linea", + "success": true, + "tokens": [ + { + "type": "protocol", + "balanceRaw": "2855886050501284774212n", + "address": "0xf374229a18ff691406f99CCBD93e8a3f16B68888", + "symbol": "ZEROvp", + "name": "ZERO Voting Power - Unlock time 04/09/2025", + "decimals": 18, + "tokens": [ + { + "address": "0x78354f8DcCB269a615A7e0a24f9B0718FDC3C7A7", + "name": "ZeroLend", + "symbol": "ZERO", + "decimals": 18, + "type": "underlying", + "balanceRaw": "2855886050501284774212n", + "balance": 2855.886050501285, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/linea/assets/0x78354f8DcCB269a615A7e0a24f9B0718FDC3C7A7/logo.png" + }, + { + "address": "0x78354f8DcCB269a615A7e0a24f9B0718FDC3C7A7", + "name": "ZeroLend", + "symbol": "ZERO", + "decimals": 18, + "balanceRaw": "56847709082345108240n", + "type": "underlying-claimable", + "balance": 56.847709082345105, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/linea/assets/0x78354f8DcCB269a615A7e0a24f9B0718FDC3C7A7/logo.png" + } + ], + "balance": 2855.886050501285 + } + ] + } + ], + "rpcResponses": { + "261f792c24ca629152145913c78beaac": { + "result": "0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000094b6000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000009ad1616fcc525ec1440000000000000000000000000000000000000000000000000000000068b8d6800000000000000000000000000000000000000000000000000000000066db4d5900000000000000000000000000000000000000000000002668def9bc98c2c5ce" + }, + "295842b540051b301001be7509abed13": { + "result": "0x00000000000000000000000000000000000000000000000314eba237e3ed7310" + } + } +} diff --git a/packages/adapters-library/src/adapters/zerolend/products/vesting/tests/snapshots/linea.positions.vesting.json b/packages/adapters-library/src/adapters/zerolend/products/vesting/tests/snapshots/linea.positions.vesting.json new file mode 100644 index 000000000..f2b0bb639 --- /dev/null +++ b/packages/adapters-library/src/adapters/zerolend/products/vesting/tests/snapshots/linea.positions.vesting.json @@ -0,0 +1,102 @@ +{ + "blockNumber": 12844440, + "latency": "Latency: 0.547 seconds", + "aggregatedValues": [], + "snapshot": [ + { + "protocolId": "zerolend", + "name": "Zerolend", + "description": "Zerolend defi adapter", + "siteUrl": "", + "iconUrl": "", + "positionType": "stake", + "chainId": 59144, + "productId": "vesting", + "chainName": "linea", + "success": true, + "tokens": [ + { + "type": "protocol", + "balanceRaw": "350209440000000000000000n", + "address": "0xf374229a18ff691406f99CCBD93e8a3f16B68888", + "symbol": "ZEROvp", + "name": "ZERO Voting Power - Unlock time 04/05/2028", + "decimals": 18, + "tokens": [ + { + "address": "0x78354f8DcCB269a615A7e0a24f9B0718FDC3C7A7", + "name": "ZeroLend", + "symbol": "ZERO", + "decimals": 18, + "type": "underlying", + "balanceRaw": "350209440000000000000000n", + "balance": 350209.44, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/linea/assets/0x78354f8DcCB269a615A7e0a24f9B0718FDC3C7A7/logo.png" + }, + { + "address": "0x78354f8DcCB269a615A7e0a24f9B0718FDC3C7A7", + "name": "ZeroLend", + "symbol": "ZERO", + "decimals": 18, + "balanceRaw": "8869731892121608319827n", + "type": "underlying-claimable", + "balance": 8869.731892121608, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/linea/assets/0x78354f8DcCB269a615A7e0a24f9B0718FDC3C7A7/logo.png" + } + ], + "balance": 350209.44 + }, + { + "type": "protocol", + "balanceRaw": "25384939480532833206655n", + "address": "0xf374229a18ff691406f99CCBD93e8a3f16B68888", + "symbol": "ZEROvp", + "name": "ZERO Voting Power - Unlock time 17/08/2028", + "decimals": 18, + "tokens": [ + { + "address": "0x78354f8DcCB269a615A7e0a24f9B0718FDC3C7A7", + "name": "ZeroLend", + "symbol": "ZERO", + "decimals": 18, + "type": "underlying", + "balanceRaw": "25384939480532833206655n", + "balance": 25384.939480532834, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/linea/assets/0x78354f8DcCB269a615A7e0a24f9B0718FDC3C7A7/logo.png" + } + ], + "balance": 25384.939480532834 + }, + { + "type": "protocol", + "balanceRaw": "411712271113939483990425n", + "address": "0xf374229a18ff691406f99CCBD93e8a3f16B68888", + "symbol": "ZEROvp", + "name": "ZERO Voting Power - Unlock time 24/08/2028", + "decimals": 18, + "tokens": [ + { + "address": "0x78354f8DcCB269a615A7e0a24f9B0718FDC3C7A7", + "name": "ZeroLend", + "symbol": "ZERO", + "decimals": 18, + "type": "underlying", + "balanceRaw": "411712271113939483990425n", + "balance": 411712.27111393947, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/linea/assets/0x78354f8DcCB269a615A7e0a24f9B0718FDC3C7A7/logo.png" + } + ], + "balance": 411712.27111393947 + } + ] + } + ], + "rpcResponses": { + "fa40435a0d78ca8ed0aad2305a9a644f": { + "result": "0x000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000004c100000000000000000000000000000000000000000000000000000000000091ae00000000000000000000000000000000000000000000000000000000000091da0000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000004a28e44beedd3c900000000000000000000000000000000000000000000000000000000000006dbb9a00000000000000000000000000000000000000000000000000000000006638985d000000000000000000000000000000000000000000004a17279a89a85db9878f0000000000000000000000000000000000000000000005601ecdba5efc8b017f000000000000000000000000000000000000000000000000000000006e4607800000000000000000000000000000000000000000000000000000000066c89ef000000000000000000000000000000000000000000000055ad51be4ff42f1c5be00000000000000000000000000000000000000000000572ef789510701999999000000000000000000000000000000000000000000000000000000006e4f42000000000000000000000000000000000000000000000000000000000066cb0cb50000000000000000000000000000000000000000000057280cd495893995e167" + }, + "8d290ba0584f6c1b33eb3f9f8551dcba": { + "result": "0x0000000000000000000000000000000000000000000001e0d441d207edd2f353" + } + } +} diff --git a/packages/adapters-library/src/adapters/zerolend/products/vesting/tests/testCases.ts b/packages/adapters-library/src/adapters/zerolend/products/vesting/tests/testCases.ts new file mode 100644 index 000000000..5905256eb --- /dev/null +++ b/packages/adapters-library/src/adapters/zerolend/products/vesting/tests/testCases.ts @@ -0,0 +1,31 @@ +import { Chain } from '../../../../../core/constants/chains' +import { TimePeriod } from '../../../../../core/constants/timePeriod' +import type { TestCase } from '../../../../../types/testCase' + +export const testCases: TestCase[] = [ + { + chainId: Chain.Linea, + method: 'positions', + key: 'vesting', + + input: { + userAddress: '0x67e5cc743aF5B1b4446c44fCCDc3aAe21f844AcF', + + filterProtocolTokens: ['0xf374229a18ff691406f99CCBD93e8a3f16B68888'], + }, + + blockNumber: 12844440, + }, + { + chainId: Chain.Linea, + method: 'positions', + key: 'vesting-2', + + input: { + userAddress: '0x3130d2b8cbf0798bb1cbf2a4f527dbae953ff27f', + filterProtocolTokens: ['0xf374229a18ff691406f99CCBD93e8a3f16B68888'], + }, + + blockNumber: 12844441, + }, +] diff --git a/packages/adapters-library/src/adapters/zerolend/products/vesting/zerolendVestingAdapter.ts b/packages/adapters-library/src/adapters/zerolend/products/vesting/zerolendVestingAdapter.ts new file mode 100644 index 000000000..564661b3f --- /dev/null +++ b/packages/adapters-library/src/adapters/zerolend/products/vesting/zerolendVestingAdapter.ts @@ -0,0 +1,276 @@ +import { AdaptersController } from '../../../../core/adaptersController' +import { Chain } from '../../../../core/constants/chains' +import { CacheToDb } from '../../../../core/decorators/cacheToDb' +import { NotImplementedError } from '../../../../core/errors/errors' +import { CustomJsonRpcProvider } from '../../../../core/provider/CustomJsonRpcProvider' +import { unixTimestampToDateString } from '../../../../core/utils/unixTimestampToDateString' +import { Helpers } from '../../../../scripts/helpers' +import { + IProtocolAdapter, + ProtocolToken, +} from '../../../../types/IProtocolAdapter' +import { + GetEventsInput, + GetPositionsInput, + GetTotalValueLockedInput, + MovementsByBlock, + PositionType, + ProtocolAdapterParams, + ProtocolDetails, + ProtocolPosition, + ProtocolTokenTvl, + TokenType, + Underlying, + UnwrapExchangeRate, + UnwrapInput, +} from '../../../../types/adapter' +import { Protocol } from '../../../protocols' + +import { getAddress } from 'ethers' +import { Erc20Metadata } from '../../../../types/erc20Metadata' +import { Vesting__factory } from '../../contracts' + +type AdditionalMetadata = { + rewardTokens: Erc20Metadata[] +} + +export class ZerolendVestingAdapter implements IProtocolAdapter { + readonly productId = 'vesting' + + readonly protocolId: Protocol + readonly chainId: Chain + readonly helpers: Helpers + readonly provider: CustomJsonRpcProvider + readonly adaptersController: AdaptersController + + readonly adapterSettings = { + enablePositionDetectionByProtocolTokenTransfer: false, + includeInUnwrap: false, + } + + private readonly addresses = { + veToken: getAddress('0xf374229a18ff691406f99ccbd93e8a3f16b68888'), + underlyingToken: getAddress('0x78354f8DcCB269a615A7e0a24f9B0718FDC3C7A7'), + rewardToken: getAddress('0x78354f8DcCB269a615A7e0a24f9B0718FDC3C7A7'), + } + + constructor({ + provider, + chainId, + protocolId, + adaptersController, + helpers, + }: ProtocolAdapterParams) { + this.provider = provider + this.chainId = chainId + this.protocolId = protocolId + this.adaptersController = adaptersController + this.helpers = helpers + } + + getProtocolDetails(): ProtocolDetails { + return { + protocolId: this.protocolId, + name: 'Zerolend', + description: 'Zerolend defi adapter', + siteUrl: '', + iconUrl: '', + positionType: PositionType.Staked, + chainId: this.chainId, + productId: this.productId, + } + } + + @CacheToDb + async getProtocolTokens(): Promise[]> { + const [ + protocolTokenMetadata, + underlyingTokenMetadata, + rewardTokenMetadata, + ] = await Promise.all([ + this.helpers.getTokenMetadata(this.addresses.veToken), + this.helpers.getTokenMetadata(this.addresses.underlyingToken), + this.helpers.getTokenMetadata(this.addresses.rewardToken), + ]) + + return [ + { + ...protocolTokenMetadata, + underlyingTokens: [underlyingTokenMetadata], + rewardTokens: [rewardTokenMetadata], + }, + ] + } + + private async getRewardBalance({ + userAddress, + blockNumber, + }: GetPositionsInput): Promise { + const veTokenContract = Vesting__factory.connect( + this.addresses.veToken, + this.provider, + ) + return veTokenContract.earned(userAddress, { blockTag: blockNumber }) + } + + private async getLockedDetails({ + userAddress, + blockNumber, + }: GetPositionsInput): Promise<{ amount: bigint; end: bigint }[]> { + const veTokenContract = Vesting__factory.connect( + this.addresses.veToken, + this.provider, + ) + const nftDetails = await veTokenContract.getLockedNftDetails(userAddress, { + blockTag: blockNumber, + }) + + if (nftDetails[0].length === 0) return [] + + return nftDetails[1].map((nft) => ({ + amount: nft.amount, + end: nft.end, + })) + } + + private async getRewardPosition( + input: GetPositionsInput, + ): Promise { + const balance = await this.getRewardBalance(input) + + const { + rewardTokens: [rewardToken], + } = (await this.getProtocolTokens())[0]! + + return { + ...rewardToken!, + balanceRaw: balance, + type: TokenType.UnderlyingClaimable, + } + } + + async getPositions(input: GetPositionsInput): Promise { + const [lockedDetails, [protocolToken]] = await Promise.all([ + this.getLockedDetails(input), + this.getProtocolTokens(), + ]) + + if (lockedDetails.length === 0 || !protocolToken) { + return [] + } + + const rewardPosition = await this.getRewardPosition(input) + + const positions = await Promise.all( + lockedDetails.map(({ amount, end }) => + this.buildPositions({ amount, end }, protocolToken, input), + ), + ) + + if (rewardPosition.balanceRaw > 0n) { + positions[0]?.tokens.push(rewardPosition) + } + + return positions + } + + private async buildPositions( + { amount, end }: { amount: bigint; end: bigint }, + protocolToken: ProtocolToken, + input: GetPositionsInput, + ) { + const unwrappedToken = await this.unwrappedBalance({ + protocolTokenBalance: amount, + protocolTokenAddress: protocolToken.address, + blockNumber: input.blockNumber, + }) + + const nameWithUnlockTime = `${ + protocolToken!.name + } - Unlock time ${unixTimestampToDateString(end)}` + + const tokens = [unwrappedToken] + + return { + type: TokenType.Protocol, + balanceRaw: amount, + address: protocolToken.address, + symbol: protocolToken.symbol, + name: nameWithUnlockTime, + decimals: protocolToken.decimals, + tokens, + } + } + + async unwrap({ + protocolTokenAddress, + }: UnwrapInput): Promise { + const protocolToken = + await this.getProtocolTokenByAddress(protocolTokenAddress) + + return { + address: protocolToken.address, + symbol: protocolToken.symbol, + name: protocolToken.name, + decimals: protocolToken.decimals, + baseRate: 1, + type: TokenType.Protocol, + tokens: [ + { + ...protocolToken.underlyingTokens[0]!, + type: TokenType.Underlying, + underlyingRateRaw: BigInt(1) * BigInt(10 ** 18), + }, + ], + } + } + + async unwrappedBalance( + input: UnwrapInput & { protocolTokenBalance: bigint }, + ): Promise { + const { tokens } = await this.unwrap(input) + + const { underlyingRateRaw, ...underlyingTokenMetadata } = tokens![0]! + + return { + ...underlyingTokenMetadata, + balanceRaw: + (input.protocolTokenBalance * underlyingRateRaw) / + 10n ** BigInt(underlyingTokenMetadata.decimals), + } + } + + private async getProtocolTokenByAddress( + protocolTokenAddress: string, + ): Promise> { + return this.helpers.getProtocolTokenByAddress({ + protocolTokens: await this.getProtocolTokens(), + protocolTokenAddress, + }) + } + + async getWithdrawals({ + protocolTokenAddress, + fromBlock, + toBlock, + userAddress, + }: GetEventsInput): Promise { + throw new NotImplementedError() + } + + async getDeposits({ + protocolTokenAddress, + fromBlock, + toBlock, + userAddress, + }: GetEventsInput): Promise { + throw new NotImplementedError() + } + + async getTotalValueLocked({ + protocolTokenAddresses, + blockNumber, + }: GetTotalValueLockedInput): Promise { + throw new NotImplementedError() + } +} From 898c066b54041c87f068fd3a9894311815335d0e Mon Sep 17 00:00:00 2001 From: jpsains <32621022+jpsains@users.noreply.github.com> Date: Fri, 6 Dec 2024 13:07:15 +0000 Subject: [PATCH 4/4] feat: quickswap d-quick (#385) * feat: quickswap d-quick * feat: qucikswap * missing test output * linting and comments --------- Co-authored-by: Bernardo Garces Chapero --- matic.db | Bin 8355840 -> 8355840 bytes .../src/adapters/integration.test.ts | 7 + .../src/adapters/protocols.ts | 1 + .../d-quick/quickswapV2DQuickAdapter.ts | 153 ++ .../tests/snapshots/matic.positions.json | 528 +++++++ .../products/d-quick/tests/testCases.ts | 25 + .../pool/tests/snapshots/matic.deposits.json | 22 +- .../pool/tests/snapshots/matic.positions.json | 22 +- .../pool/tests/snapshots/matic.profits.json | 24 +- .../quickswap-v3/contracts/PositionManager.ts | 1294 +++++++++++++++++ .../contracts/abis/position-manager.json | 1 + .../adapters/quickswap-v3/contracts/common.ts | 131 ++ .../factories/PositionManager__factory.ts | 1261 ++++++++++++++++ .../quickswap-v3/contracts/factories/index.ts | 4 + .../adapters/quickswap-v3/contracts/index.ts | 6 + .../products/pool/quickswapV3PoolAdapter.ts | 369 +++++ .../tests/snapshots/matic.positions.1.json | 115 ++ .../tests/snapshots/matic.positions.2.json | 201 +++ .../pool/tests/snapshots/matic.positions.json | 1269 ++++++++++++++++ .../products/pool/tests/testCases.ts | 35 + .../src/adapters/supportedProtocols.ts | 10 +- 21 files changed, 5470 insertions(+), 8 deletions(-) create mode 100644 packages/adapters-library/src/adapters/quickswap-v2/products/d-quick/quickswapV2DQuickAdapter.ts create mode 100644 packages/adapters-library/src/adapters/quickswap-v2/products/d-quick/tests/snapshots/matic.positions.json create mode 100644 packages/adapters-library/src/adapters/quickswap-v2/products/d-quick/tests/testCases.ts create mode 100644 packages/adapters-library/src/adapters/quickswap-v3/contracts/PositionManager.ts create mode 100644 packages/adapters-library/src/adapters/quickswap-v3/contracts/abis/position-manager.json create mode 100644 packages/adapters-library/src/adapters/quickswap-v3/contracts/common.ts create mode 100644 packages/adapters-library/src/adapters/quickswap-v3/contracts/factories/PositionManager__factory.ts create mode 100644 packages/adapters-library/src/adapters/quickswap-v3/contracts/factories/index.ts create mode 100644 packages/adapters-library/src/adapters/quickswap-v3/contracts/index.ts create mode 100644 packages/adapters-library/src/adapters/quickswap-v3/products/pool/quickswapV3PoolAdapter.ts create mode 100644 packages/adapters-library/src/adapters/quickswap-v3/products/pool/tests/snapshots/matic.positions.1.json create mode 100644 packages/adapters-library/src/adapters/quickswap-v3/products/pool/tests/snapshots/matic.positions.2.json create mode 100644 packages/adapters-library/src/adapters/quickswap-v3/products/pool/tests/snapshots/matic.positions.json create mode 100644 packages/adapters-library/src/adapters/quickswap-v3/products/pool/tests/testCases.ts diff --git a/matic.db b/matic.db index 8d6b964fe7db8b8d77da3feb6a48c159dc387e09..862a8b332fd62d51919607ad31a61aa50aca86ca 100644 GIT binary patch delta 52532 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 Llk#+T!|wkDCVT<* delta 36007 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 z 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 as^1UZU65@A%U8~JIFx6d_Huj8;r|WbDAN=G diff --git a/packages/adapters-library/src/adapters/integration.test.ts b/packages/adapters-library/src/adapters/integration.test.ts index 9a0635a1b..837458ba6 100644 --- a/packages/adapters-library/src/adapters/integration.test.ts +++ b/packages/adapters-library/src/adapters/integration.test.ts @@ -86,7 +86,9 @@ import { testCases as pendlePrincipleTokenTestCases } from './pendle/products/pr import { testCases as pendleStandardisedYieldTokenTestCases } from './pendle/products/standardised-yield-token/tests/testCases' import { testCases as pendleYieldTokenTestCases } from './pendle/products/yield-token/tests/testCases' import { Protocol } from './protocols' +import { testCases as quickswapV2DQuickTestCases } from './quickswap-v2/products/d-quick/tests/testCases' import { testCases as quickswapV2PoolTestCases } from './quickswap-v2/products/pool/tests/testCases' +import { testCases as quickswapV3PoolTestCases } from './quickswap-v3/products/pool/tests/testCases' import { testCases as renzoEzEthTestCases } from './renzo/products/ez-eth/tests/testCases' import { testCases as rocketPoolRethTestCases } from './rocket-pool/products/reth/tests/testCases' import { testCases as solvSolvBtcTestCases } from './solv/products/solv-btc/tests/testCases' @@ -306,9 +308,14 @@ const allTestCases: Record> = { }, [Protocol.QuickswapV2]: { + ['d-quick']: quickswapV2DQuickTestCases, ['pool']: quickswapV2PoolTestCases, }, + [Protocol.QuickswapV3]: { + ['pool']: quickswapV3PoolTestCases, + }, + [Protocol.Renzo]: { ['ez-eth']: renzoEzEthTestCases, }, diff --git a/packages/adapters-library/src/adapters/protocols.ts b/packages/adapters-library/src/adapters/protocols.ts index 68bc80aa0..5a0426d26 100644 --- a/packages/adapters-library/src/adapters/protocols.ts +++ b/packages/adapters-library/src/adapters/protocols.ts @@ -31,6 +31,7 @@ export const Protocol = { PancakeswapV2: 'pancakeswap-v2', Pendle: 'pendle', QuickswapV2: 'quickswap-v2', + QuickswapV3: 'quickswap-v3', Renzo: 'renzo', RocketPool: 'rocket-pool', Solv: 'solv', diff --git a/packages/adapters-library/src/adapters/quickswap-v2/products/d-quick/quickswapV2DQuickAdapter.ts b/packages/adapters-library/src/adapters/quickswap-v2/products/d-quick/quickswapV2DQuickAdapter.ts new file mode 100644 index 000000000..d8a1b05b1 --- /dev/null +++ b/packages/adapters-library/src/adapters/quickswap-v2/products/d-quick/quickswapV2DQuickAdapter.ts @@ -0,0 +1,153 @@ +import { AdaptersController } from '../../../../core/adaptersController' +import { Chain } from '../../../../core/constants/chains' +import { CacheToDb } from '../../../../core/decorators/cacheToDb' +import { CustomJsonRpcProvider } from '../../../../core/provider/CustomJsonRpcProvider' +import { Helpers } from '../../../../scripts/helpers' +import { + IProtocolAdapter, + ProtocolToken, +} from '../../../../types/IProtocolAdapter' +import { + GetEventsInput, + GetPositionsInput, + GetTotalValueLockedInput, + MovementsByBlock, + PositionType, + ProtocolAdapterParams, + ProtocolDetails, + ProtocolPosition, + ProtocolTokenTvl, + UnwrapExchangeRate, + UnwrapInput, +} from '../../../../types/adapter' +import { Protocol } from '../../../protocols' + +export class QuickswapV2DQuickAdapter implements IProtocolAdapter { + productId = 'd-quick' + protocolId: Protocol + chainId: Chain + helpers: Helpers + + adapterSettings = { + enablePositionDetectionByProtocolTokenTransfer: true, + includeInUnwrap: true, + } + + private provider: CustomJsonRpcProvider + + adaptersController: AdaptersController + + constructor({ + provider, + chainId, + protocolId, + adaptersController, + helpers, + }: ProtocolAdapterParams) { + this.provider = provider + this.chainId = chainId + this.protocolId = protocolId + this.adaptersController = adaptersController + this.helpers = helpers + } + + /** + * Update me. + * Add your protocol details + */ + getProtocolDetails(): ProtocolDetails { + return { + protocolId: this.protocolId, + name: 'QuickswapV2', + description: 'QuickswapV2 defi adapter', + siteUrl: 'https:', + iconUrl: 'https://', + positionType: PositionType.Supply, + chainId: this.chainId, + productId: this.productId, + } + } + + @CacheToDb + async getProtocolTokens(): Promise { + const protocolToken = await this.helpers.getTokenMetadata( + '0x958d208Cdf087843e9AD98d23823d32E17d723A1', + ) + + const underlyingToken = await this.helpers.getTokenMetadata( + '0xB5C064F955D8e7F38fE0460C556a72987494eE17', + ) + + return [ + { + ...protocolToken, + underlyingTokens: [underlyingToken], + }, + ] + } + + private async getProtocolTokenByAddress(protocolTokenAddress: string) { + return this.helpers.getProtocolTokenByAddress({ + protocolTokens: await this.getProtocolTokens(), + protocolTokenAddress, + }) + } + + async getPositions(input: GetPositionsInput): Promise { + return this.helpers.getBalanceOfTokens({ + ...input, + protocolTokens: await this.getProtocolTokens(), + }) + } + + async getWithdrawals({ + protocolTokenAddress, + fromBlock, + toBlock, + userAddress, + }: GetEventsInput): Promise { + return this.helpers.withdrawals({ + protocolToken: await this.getProtocolTokenByAddress(protocolTokenAddress), + filter: { fromBlock, toBlock, userAddress }, + }) + } + + async getDeposits({ + protocolTokenAddress, + fromBlock, + toBlock, + userAddress, + }: GetEventsInput): Promise { + return this.helpers.deposits({ + protocolToken: await this.getProtocolTokenByAddress(protocolTokenAddress), + filter: { fromBlock, toBlock, userAddress }, + }) + } + + async getTotalValueLocked({ + protocolTokenAddresses, + blockNumber, + }: GetTotalValueLockedInput): Promise { + const protocolTokens = await this.getProtocolTokens() + + return await this.helpers.tvl({ + protocolTokens, + filterProtocolTokenAddresses: protocolTokenAddresses, + blockNumber, + }) + } + + async unwrap({ + protocolTokenAddress, + tokenId, + blockNumber, + }: UnwrapInput): Promise { + return this.helpers.unwrapTokenAsRatio({ + protocolToken: await this.getProtocolTokenByAddress(protocolTokenAddress), + underlyingTokens: ( + await this.getProtocolTokenByAddress(protocolTokenAddress) + ).underlyingTokens, + blockNumber, + }) + } +} diff --git a/packages/adapters-library/src/adapters/quickswap-v2/products/d-quick/tests/snapshots/matic.positions.json b/packages/adapters-library/src/adapters/quickswap-v2/products/d-quick/tests/snapshots/matic.positions.json new file mode 100644 index 000000000..bbb5312df --- /dev/null +++ b/packages/adapters-library/src/adapters/quickswap-v2/products/d-quick/tests/snapshots/matic.positions.json @@ -0,0 +1,528 @@ +{ + "blockNumber": 65028666, + "latency": "Latency: 2.355 seconds", + "aggregatedValues": ["USD256.07"], + "snapshot": [ + { + "protocolId": "quickswap-v2", + "name": "QuickswapV2", + "description": "QuickswapV2 defi adapter", + "siteUrl": "https:", + "iconUrl": "https://", + "positionType": "supply", + "chainId": 137, + "productId": "d-quick", + "chainName": "matic", + "success": true, + "tokens": [ + { + "address": "0x958d208Cdf087843e9AD98d23823d32E17d723A1", + "name": "Dragon QUICK", + "symbol": "dQUICK", + "decimals": 18, + "balanceRaw": "3429973373192860286546n", + "type": "protocol", + "tokens": [ + { + "address": "0xB5C064F955D8e7F38fE0460C556a72987494eE17", + "name": "QuickSwap", + "symbol": "QUICK", + "decimals": 18, + "type": "underlying", + "balanceRaw": "4361107175984182870354n", + "balance": 4361.1071759841825, + "price": 0.05871675236750279, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/polygon/assets/0xB5C064F955D8e7F38fE0460C556a72987494eE17/logo.png" + } + ], + "balance": 3429.9733731928604 + } + ] + } + ], + "rpcResponses": { + "1968d4ace1996261736726d258701a82": { + "result": "0x3e0434e" + }, + "1a6cba2f712eb03d550088b6e5256608": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000664515549434b0000000000000000000000000000000000000000000000000000" + }, + "54b94a088c93c02ab766dc6e0052ce2b": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000c447261676f6e20515549434b0000000000000000000000000000000000000000" + }, + "df2e402a0e9021892e5489ddd141d858": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000012" + }, + "22ed18ebf436acacc807f71c099651b6": { + "result": [ + { + "address": "0xe61b8c377dcc05480163999a3efd51419a70c670", + "blockHash": "0xa0a9848606d3faa27f3187ff205a621fc9fc15b961fb7280fed69c13533d87ed", + "blockNumber": "0x11581d8", + "data": "0x", + "logIndex": "0x137", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3", + "0x00000000000000000000000000000000000000000000000000000000000007c2" + ], + "transactionHash": "0x50985b091cedf5740e448be9df8f33d4b6688337f87cba9b5bf14777c65044a7", + "transactionIndex": "0x28" + }, + { + "address": "0x3af869dbb5c8ef55e5758ec8d15eabe32d6329b1", + "blockHash": "0x204f1fa7c33e692a88fd41072180a6d71f6cfa397eecb47f6b4e050437ba50a6", + "blockNumber": "0x1798d18", + "data": "0x", + "logIndex": "0xbe", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3", + "0x0000000000000000000000000000000000000000000000000000000000010bc2" + ], + "transactionHash": "0x75db6591c37ef0350d9138f85cec61b3d4b0eca365429b552c44c71452a60ceb", + "transactionIndex": "0x2a" + }, + { + "address": "0x1099b916db28863657643b41a0bf58ac73bc9d44", + "blockHash": "0xa739264e325b4965af445d43714422caabead9ac1fa503420b20780e9ea26f63", + "blockNumber": "0x17fe75d", + "data": "0x", + "logIndex": "0xca", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3", + "0x00000000000000000000000000000000000000000000000000000000000026c3" + ], + "transactionHash": "0xa6985b174079bec56e2676ff3f3394ae35200e5b15108473af1b59a62d8bf01d", + "transactionIndex": "0x2a" + }, + { + "address": "0xf8c3cd5d4eb0b77b59b98c9c1314f8df90a42d92", + "blockHash": "0x54198a830a8e1174214201ccb4933a572a53e409ff0015dd5a701b60af7478a9", + "blockNumber": "0x187a7be", + "data": "0x", + "logIndex": "0x1bd", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3", + "0x00000000000000000000000000000000000000000000000000000000000015c7" + ], + "transactionHash": "0x14355f83c2e3f48f98e80d518b72a07c96065effae6fdfd2dc83305791b63fa6", + "transactionIndex": "0x22" + }, + { + "address": "0xbdb49e024fb25bcef581f51d8e90c0667c3013d2", + "blockHash": "0x5d5a7f1b995c2c1bddf77d98f602d3971e0785763b0249202cb77f0ccdd94176", + "blockNumber": "0x188bf04", + "data": "0x", + "logIndex": "0x166", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3", + "0x00000000000000000000000000000000000000000000000000000000000008bf" + ], + "transactionHash": "0x5198d490e7d80cf3fc0f66059677bf3a5f5748ca6869fb2ffe0f17d57cc5dc32", + "transactionIndex": "0x22" + }, + { + "address": "0x74ad5297c36f7fceb8bb421db3c9864a611bc946", + "blockHash": "0x0a0afccf70a2a3dbb93f7dc482bc412556b9eaf1324eec7de645166fc422cef6", + "blockNumber": "0x18a5425", + "data": "0x", + "logIndex": "0xba", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3", + "0x0000000000000000000000000000000000000000000000000000000000000467" + ], + "transactionHash": "0x16f8d162cbb21b321d2dae06558b6b7da1801772e5fa973e03be45915c5ebd12", + "transactionIndex": "0x20" + }, + { + "address": "0x464f598edc572602ec4ec06f0911f5218cf82fd9", + "blockHash": "0x9c1ea8b5bd890840e4f33f5359d7233ae14b872946b2d731ba45c09e90d9eec2", + "blockNumber": "0x18cf9f7", + "data": "0x", + "logIndex": "0x1fe", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3", + "0x000000000000000000000000000000000000000000000000000000000000072d" + ], + "transactionHash": "0x87b617be8429a3b601ba9e557b1ff0bc92ad0a1f5520a1926444cd1c67a741bc", + "transactionIndex": "0x24" + }, + { + "address": "0xc863ea79f6825fb4b3361764d82f10ad006626f3", + "blockHash": "0xd83e05a60156836108d7aeb9cfc60c02571fafdadfd7a337a10d16e469814090", + "blockNumber": "0x18cfbd2", + "data": "0x", + "logIndex": "0x1d4", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3", + "0x0000000000000000000000000000000000000000000000000000000000000d0e" + ], + "transactionHash": "0x9907d88e53fab2cfeb872286ff690dda4631a2c02b4299a07077f6b1f09f70db", + "transactionIndex": "0x26" + }, + { + "address": "0xe46912c22948c190368a8e8ffe245484764a93b7", + "blockHash": "0xe5d9e2bc14e60befedacc3b471f549a18285bde10dcc5798b36f3eb8242f4653", + "blockNumber": "0x19d32bc", + "data": "0x", + "logIndex": "0xd1", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3", + "0x0000000000000000000000000000000000000000000000000000000000000041" + ], + "transactionHash": "0x2b108682cb2e836145faa3507e87603a7df6453833bfddb7929c1b5379b3c59f", + "transactionIndex": "0x2c" + }, + { + "address": "0xe46912c22948c190368a8e8ffe245484764a93b7", + "blockHash": "0x94bf3c451007f017739fae3e330dfcad6bff5e4c23c62790c0f77210910f1e4f", + "blockNumber": "0x19d3611", + "data": "0x", + "logIndex": "0xb7", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3", + "0x0000000001000000000000000000000000000000000000000000000000000040" + ], + "transactionHash": "0xcf27ef88383593c5e0d9d04cd0fe8f2485571672a26607855d14313cc40a81f8", + "transactionIndex": "0x1d" + }, + { + "address": "0x74ad5297c36f7fceb8bb421db3c9864a611bc946", + "blockHash": "0x71064dc0a1fffbd965801c0bdc3bd5dec00f6dd56c944b2c3d80deb9cf80aed5", + "blockNumber": "0x1a19843", + "data": "0x", + "logIndex": "0x1a3", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3", + "0x00000000010000000000000000000000000000000000000000000000000004a9" + ], + "transactionHash": "0xbc764c6b74c56fad766486ed85c713ecc1bf59a4a2974c333ee0d19f01e2629e", + "transactionIndex": "0x28" + }, + { + "address": "0x675928792a0b1564ad615261eb4a82a38ced2915", + "blockHash": "0x0f1d711a8bda4793f46350d0a303bd02766c4c91fa3c1dfdbbd1e1c0d87148e4", + "blockNumber": "0x1af7198", + "data": "0x", + "logIndex": "0x223", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3", + "0x0000000000000000000000000000000000000000000000000000000000004595" + ], + "transactionHash": "0x6db062e0ee7693028553c905a5936a929d62cf4043f029d6e2179167cfd32a60", + "transactionIndex": "0x5e" + }, + { + "address": "0xa67d2c07ce63b60e218a54d990806ad67ec234ea", + "blockHash": "0x4cf776e3f97122fecfe44f7abe84b478a9e5a5235d395fb4d3c579de3c4e63fa", + "blockNumber": "0x1cd3c53", + "data": "0x", + "logIndex": "0x70", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3", + "0x00000000000000000000000000000000000000000000000000000000000086d0" + ], + "transactionHash": "0xea851272158e25261dd8519924bf650e0055aac3ab964f951735d265edf94ce4", + "transactionIndex": "0x0" + }, + { + "address": "0x0fa71d08572a444cae6b5a30f5edc3f71f27a8fe", + "blockHash": "0xec349e1f812c16aeea9424767534528fa11cd98ea42d06cd913d7295c21e32f4", + "blockNumber": "0x1e3383f", + "data": "0x", + "logIndex": "0x106", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3", + "0x000000000000000000000000000000000000000000000000000000000000017d" + ], + "transactionHash": "0xb9162bfe26f997f9b3c4b3b8131a5b728c7476a8e63c51e2b1b017367e2d5d97", + "transactionIndex": "0x1b" + }, + { + "address": "0x0fa71d08572a444cae6b5a30f5edc3f71f27a8fe", + "blockHash": "0xd0e295206edd9706b6960dbf068f17bd6b67ca20dc7ce82ee0507d7cbed02a49", + "blockNumber": "0x1e33a35", + "data": "0x", + "logIndex": "0xee", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3", + "0x000000000100000000000000000000000000000000000000000000000000017d" + ], + "transactionHash": "0x4c58ece843ed0560d00e45a551bc1be7c35d8f65d9eb215512eb78a02244795c", + "transactionIndex": "0x18" + }, + { + "address": "0x705519a01c5a33cd84877f6ccc41b7683eccff3c", + "blockHash": "0x5d73240e9b6c914e9eee9175f999dad3012c92aa7b22b94789d436cc7252d18f", + "blockNumber": "0x1e8bd01", + "data": "0x", + "logIndex": "0x529", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3", + "0x00000000000000000000000000000000000000000000000000000000000000e2" + ], + "transactionHash": "0x89d362cb5709b87c28b37a1b805fd63514db2032c964c1faf980a08b44341379", + "transactionIndex": "0x45" + }, + { + "address": "0x9bea7063aa2de20bb3646fe277f8bf40fb87575e", + "blockHash": "0x3f711a6b449ed3858be6a21a348d077c89032fbf3049391a5845c4018e49c7f9", + "blockNumber": "0x1f55ac1", + "data": "0x", + "logIndex": "0x3f", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3", + "0x000000000000000000000000000000000000000000000000000000000000125e" + ], + "transactionHash": "0x35bf3535f76dbbda6cb48c223bd54a44512193c1871f8597a1797faaee799189", + "transactionIndex": "0x13" + }, + { + "address": "0x93fdfb08ba1defa3b7dbd2f3d0cfbf29234db7d5", + "blockHash": "0x4dd95ee2380cea5dfae2e93554348ec72c3e963d06f6295c9b791ccb956c8991", + "blockNumber": "0x1f7433e", + "data": "0x", + "logIndex": "0xca", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3", + "0x000000000000000000000000000000000000000000000000000000000004e8b4" + ], + "transactionHash": "0x63f497f0e6e0c42452057f3ff3d784200fb1e907f6ecf7f1b228e5dc373426b1", + "transactionIndex": "0x15" + }, + { + "address": "0xa024558d90d79d33143b40140e5e22b5e1de2c50", + "blockHash": "0x2e1bb3e16599bdd897d1255b27c79df929b1525d5eac5f1ef6de562e7c384029", + "blockNumber": "0x1fa5319", + "data": "0x", + "logIndex": "0x107", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3", + "0x0000000000000000000000000000000000000000000000000000000000000cb7" + ], + "transactionHash": "0xb13daa35c94f6c8951b5710c74a81281cef4a3a221b7cadfc24eccc0a33b4ed3", + "transactionIndex": "0x37" + }, + { + "address": "0xa024558d90d79d33143b40140e5e22b5e1de2c50", + "blockHash": "0xd7adfc14e0bac6eb1cd494a5e7b5c2c061dc2f10ab7bda4bd389341c57fb8fd5", + "blockNumber": "0x217b9e2", + "data": "0x", + "logIndex": "0x18e", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3", + "0x0000000000000000000000000000000000000000000000000000000000003cc1" + ], + "transactionHash": "0xc58ab5384f6cba1914da5f8254b9806cc89e2bee430f0408cd86fe43c38120b1", + "transactionIndex": "0x77" + }, + { + "address": "0xbc61f10a02396dad9047a38e4fd5cad02443b924", + "blockHash": "0x6ccba4bbbbd5d951d32205fbd4357e6cf66b8d9b25a7fa024ba0c60820ad2a55", + "blockNumber": "0x22c64c6", + "data": "0x", + "logIndex": "0x20b", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3", + "0x00000000000000000000000000000000000000000000000000000000000406be" + ], + "transactionHash": "0x5ca1a75245a7ca35a7d1eabdd7eefe69b0cb6277c568ab60c902655ccfd28bf6", + "transactionIndex": "0x40" + }, + { + "address": "0x1f684f73981774d46dedcfad30f78a6943866886", + "blockHash": "0x8927cf758025260ed893e57cc46b2297e40787c8d54f17bc27839d9aa20cd285", + "blockNumber": "0x22c8104", + "data": "0x", + "logIndex": "0x0", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3", + "0x00000000000000000000000000000000000000000000000000000000000022ea" + ], + "transactionHash": "0xd1d5ec930b0288c56e9440d735c2a1aad467d571b18e846f7b3bc720973967fd", + "transactionIndex": "0x0" + }, + { + "address": "0x5b4a29a8663a9623dd4b684c37a869f80be96f5c", + "blockHash": "0x520912f6810e07c074d55e35587a7e4b9cac045b05150fa7e1b15678819675cc", + "blockNumber": "0x23e4aa5", + "data": "0x", + "logIndex": "0x146", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3", + "0x0000000000000000000000000000000000000000000000000000000000000103" + ], + "transactionHash": "0x617707bc0e5d1c3cb2036d5e147d4227e135ef5327dc68323aa3c5c290acae75", + "transactionIndex": "0x19" + }, + { + "address": "0xecc967004b41f38daade93beefaaed1d8b10c39b", + "blockHash": "0x38039f26b6a49b26d6037756f47e8c7e01392c95eef744211fa0f4975c7448b6", + "blockNumber": "0x3053d72", + "data": "0x00000000000000000000000000000000000000000000010f0cf064dd59200000", + "logIndex": "0x22a", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3" + ], + "transactionHash": "0xfc7065d77d5fdc06f51bacef03746f61c3854d45c786161913a8c4d72d54b51b", + "transactionIndex": "0x35" + }, + { + "address": "0x54c9f0ffb88071a701aa2e1a9b23ea63dac39f9f", + "blockHash": "0x2535b4c7f8763085df69fd29bce30aeb534bf5d488eff910b464f2764c63c0e6", + "blockNumber": "0x313dbfc", + "data": "0x0000000000000000000000000000000000000000000000000000000000000001", + "logIndex": "0xdc", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3" + ], + "transactionHash": "0x8a540ea4a83a4bc109d195510a3fc159acfb8ec2de15eb462d3d43eb00f27a93", + "transactionIndex": "0x30" + }, + { + "address": "0x958d208cdf087843e9ad98d23823d32e17d723a1", + "blockHash": "0x0e4e1d9642782333c9f08901c861c3e7b3d5a7ba6fc47c09dcf40595893873af", + "blockNumber": "0x3482959", + "data": "0x0000000000000000000000000000000000000000000000b9f071522420c73e52", + "logIndex": "0x199", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3" + ], + "transactionHash": "0xe450e0e6f8e12c6fd324984f4d4487918e7534571e300c16c13e9450072bbfb4", + "transactionIndex": "0x38" + }, + { + "address": "0x5ae056849c3fb037bdd6dd0fd54ac6cf3f551f0c", + "blockHash": "0xa492094c67c20ef9df5a43844ffff7ee3495142f020f8a72c66fc8fb535041d9", + "blockNumber": "0x365c1d2", + "data": "0x0000000000000000000000000000000000000000000000000000000000000001", + "logIndex": "0x43a", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3" + ], + "transactionHash": "0x48de504895a00aa3b9d9b3ce2cb708ebbe3f71e023f742d8c8cdf1a06d181a97", + "transactionIndex": "0x2e" + }, + { + "address": "0x0c7f4fa80d25647374bd7a962260bb181b9b91f9", + "blockHash": "0xd62513609cb38b09a6964ebd801018b18a5f06c7a657ef6459bb6f8d6587a36a", + "blockNumber": "0x36d5139", + "data": "0x0000000000000000000000000000000000000000000000000000000000000001", + "logIndex": "0x217", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000947b7d38421e2701852246cf18ef6ae19c299bf3" + ], + "transactionHash": "0x3ee84d3bf026d0629c6b54f3e7b1581d9f335b9f1065b98ff1ea3314e0077e37", + "transactionIndex": "0x38" + } + ] + }, + "fbd62bb4d59f735945937c77e97ec140": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000012" + }, + "91a8a265314fc5d58d4c169d055252be": { + "result": "0x00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000005515549434b000000000000000000000000000000000000000000000000000000" + }, + "6e23381abc6c331e1890521436aec7a3": { + "result": "0x00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000009517569636b537761700000000000000000000000000000000000000000000000" + }, + "bb4263693376d4cf8e0150bfd454d67b": { + "result": "0x0000000000000000000000000000000000000000000000b9f071522420c73e52" + }, + "6e7d339f80d6eb7348483d76cc4cccaf": { + "result": "0x00000000000000000000000000000000000000000070576cbf4c961f1e3beb1b" + }, + "a558fecaf961dc6d9754b33a89f49f5e": { + "result": "0x0000000000000000000000000000000000000000008ed6bca43b225e39056b0f" + }, + "8ec803bee1520fa23d8073bc8d16f1c0": { + "result": "0x000000000000000000000000000000000000000000000003000000000016abaa0000000000000000000000000000000000000000000000000000005425d140c100000000000000000000000000000000000000000000000000000000674ed9b200000000000000000000000000000000000000000000000000000000674ed9b7000000000000000000000000000000000000000000000003000000000016abaa" + }, + "d5f14ab61b5def403c95e29bfdc12eb3": { + "result": "0x00000000000000000000000000000000000000000000000000000ec6aecea39e" + } + } +} diff --git a/packages/adapters-library/src/adapters/quickswap-v2/products/d-quick/tests/testCases.ts b/packages/adapters-library/src/adapters/quickswap-v2/products/d-quick/tests/testCases.ts new file mode 100644 index 000000000..cdc6d4525 --- /dev/null +++ b/packages/adapters-library/src/adapters/quickswap-v2/products/d-quick/tests/testCases.ts @@ -0,0 +1,25 @@ +import { Chain } from '../../../../../core/constants/chains' +import { TimePeriod } from '../../../../../core/constants/timePeriod' +import type { TestCase } from '../../../../../types/testCase' + +export const testCases: TestCase[] = [ + { + chainId: Chain.Polygon, + method: 'positions', + + input: { + userAddress: '0x947b7d38421E2701852246Cf18EF6AE19C299BF3', + filterProtocolTokens: ['0x958d208Cdf087843e9AD98d23823d32E17d723A1'], + }, + + blockNumber: 65028666, + }, + // { + // chainId: Chain.Ethereum, + // method: 'profits', + // input: { + // userAddress: '0xCEadFdCCd0E8E370D985c49Ed3117b2572243A4a', + // timePeriod: TimePeriod.oneDay, + // }, + // }, +] diff --git a/packages/adapters-library/src/adapters/quickswap-v2/products/pool/tests/snapshots/matic.deposits.json b/packages/adapters-library/src/adapters/quickswap-v2/products/pool/tests/snapshots/matic.deposits.json index 99907c855..26be6b96e 100644 --- a/packages/adapters-library/src/adapters/quickswap-v2/products/pool/tests/snapshots/matic.deposits.json +++ b/packages/adapters-library/src/adapters/quickswap-v2/products/pool/tests/snapshots/matic.deposits.json @@ -81,12 +81,30 @@ } ] }, - "35c3c53ad19ef8dac1ee12fc8767612b": { - "result": "0x0000000000000000000000000000000000000000000003541c86b838437f9560" + "54b94a088c93c02ab766dc6e0052ce2b": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000c447261676f6e20515549434b0000000000000000000000000000000000000000" + }, + "1a6cba2f712eb03d550088b6e5256608": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000664515549434b0000000000000000000000000000000000000000000000000000" + }, + "df2e402a0e9021892e5489ddd141d858": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000012" + }, + "fbd62bb4d59f735945937c77e97ec140": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000012" + }, + "91a8a265314fc5d58d4c169d055252be": { + "result": "0x00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000005515549434b000000000000000000000000000000000000000000000000000000" + }, + "6e23381abc6c331e1890521436aec7a3": { + "result": "0x00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000009517569636b537761700000000000000000000000000000000000000000000000" }, "c9afc05a52da82dad8ad9d1f6d8be912": { "result": "0x00000000000000000000000000000000000000000001252ee461d1bc6681d664000000000000000000000000000000000000000000000016823f87b4db9961560000000000000000000000000000000000000000000000000000000065e27c4c" }, + "35c3c53ad19ef8dac1ee12fc8767612b": { + "result": "0x0000000000000000000000000000000000000000000003541c86b838437f9560" + }, "128254ba6528097a64c5a08b3fd3b473": { "result": "0x000000000000000000000000000000000000000000000002000000000072070a000000000000000000000000000000000000000000000000000000502bbe7f240000000000000000000000000000000000000000000000000000000065e27c4a0000000000000000000000000000000000000000000000000000000065e27c4a000000000000000000000000000000000000000000000002000000000072070a" }, diff --git a/packages/adapters-library/src/adapters/quickswap-v2/products/pool/tests/snapshots/matic.positions.json b/packages/adapters-library/src/adapters/quickswap-v2/products/pool/tests/snapshots/matic.positions.json index 1c728df6a..9cb1660fa 100644 --- a/packages/adapters-library/src/adapters/quickswap-v2/products/pool/tests/snapshots/matic.positions.json +++ b/packages/adapters-library/src/adapters/quickswap-v2/products/pool/tests/snapshots/matic.positions.json @@ -52,15 +52,33 @@ } ], "rpcResponses": { + "54b94a088c93c02ab766dc6e0052ce2b": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000c447261676f6e20515549434b0000000000000000000000000000000000000000" + }, + "1a6cba2f712eb03d550088b6e5256608": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000664515549434b0000000000000000000000000000000000000000000000000000" + }, + "df2e402a0e9021892e5489ddd141d858": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000012" + }, "5a30a9ca3efe5755f6a793ec3a4e7e89": { "result": "0x00000000000000000000000000000000000000000000000000000000197f5ada" }, - "66ed173e1c19217308379744b6bb27ce": { - "result": "0x000000000000000000000000000000000000000000000000000001dce1243d0c" + "6e23381abc6c331e1890521436aec7a3": { + "result": "0x00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000009517569636b537761700000000000000000000000000000000000000000000000" + }, + "91a8a265314fc5d58d4c169d055252be": { + "result": "0x00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000005515549434b000000000000000000000000000000000000000000000000000000" + }, + "fbd62bb4d59f735945937c77e97ec140": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000012" }, "b2ffc1485618af07a7913e3d215200e9": { "result": "0x00000000000000000000000000000000000000000000000000000000972b56b5000000000000000000000000000000000000000000000018f5c3513becc953090000000000000000000000000000000000000000000000000000000065e43eca" }, + "66ed173e1c19217308379744b6bb27ce": { + "result": "0x000000000000000000000000000000000000000000000000000001dce1243d0c" + }, "8ae3f3ad2705fc2bab41fc340ebd920c": { "result": "0x00000000000000000000000000000000000000000000000200000000007233360000000000000000000000000000000000000000000000000000004f85af4f540000000000000000000000000000000000000000000000000000000065e444be0000000000000000000000000000000000000000000000000000000065e444be0000000000000000000000000000000000000000000000020000000000723336" }, diff --git a/packages/adapters-library/src/adapters/quickswap-v2/products/pool/tests/snapshots/matic.profits.json b/packages/adapters-library/src/adapters/quickswap-v2/products/pool/tests/snapshots/matic.profits.json index 332a04af4..32260e334 100644 --- a/packages/adapters-library/src/adapters/quickswap-v2/products/pool/tests/snapshots/matic.profits.json +++ b/packages/adapters-library/src/adapters/quickswap-v2/products/pool/tests/snapshots/matic.profits.json @@ -40,9 +40,27 @@ "c58b731acf735e431025467f44b4a7bd": { "result": "0x00000000000000000000000000000000000000000000000000c900106abd7655" }, + "df2e402a0e9021892e5489ddd141d858": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000012" + }, + "1a6cba2f712eb03d550088b6e5256608": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000664515549434b0000000000000000000000000000000000000000000000000000" + }, + "54b94a088c93c02ab766dc6e0052ce2b": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000c447261676f6e20515549434b0000000000000000000000000000000000000000" + }, "565a9c4f9edeb46f8ebc9f0d32c29d70": { "result": "0x0000000000000000000000000000000000000000000000000000000000000000" }, + "6e23381abc6c331e1890521436aec7a3": { + "result": "0x00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000009517569636b537761700000000000000000000000000000000000000000000000" + }, + "91a8a265314fc5d58d4c169d055252be": { + "result": "0x00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000005515549434b000000000000000000000000000000000000000000000000000000" + }, + "fbd62bb4d59f735945937c77e97ec140": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000012" + }, "fcc9e8eb6ceb96ece9ff4cf553254c1b": { "result": "0x00000000000000000000000000000000000000000000034beb47cd6dd0e40689" }, @@ -77,12 +95,12 @@ } ] }, - "35c3c53ad19ef8dac1ee12fc8767612b": { - "result": "0x0000000000000000000000000000000000000000000003541c86b838437f9560" - }, "c9afc05a52da82dad8ad9d1f6d8be912": { "result": "0x00000000000000000000000000000000000000000001252ee461d1bc6681d664000000000000000000000000000000000000000000000016823f87b4db9961560000000000000000000000000000000000000000000000000000000065e27c4c" }, + "35c3c53ad19ef8dac1ee12fc8767612b": { + "result": "0x0000000000000000000000000000000000000000000003541c86b838437f9560" + }, "128254ba6528097a64c5a08b3fd3b473": { "result": "0x000000000000000000000000000000000000000000000002000000000072070a000000000000000000000000000000000000000000000000000000502bbe7f240000000000000000000000000000000000000000000000000000000065e27c4a0000000000000000000000000000000000000000000000000000000065e27c4a000000000000000000000000000000000000000000000002000000000072070a" }, diff --git a/packages/adapters-library/src/adapters/quickswap-v3/contracts/PositionManager.ts b/packages/adapters-library/src/adapters/quickswap-v3/contracts/PositionManager.ts new file mode 100644 index 000000000..4d498e185 --- /dev/null +++ b/packages/adapters-library/src/adapters/quickswap-v3/contracts/PositionManager.ts @@ -0,0 +1,1294 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumberish, + BytesLike, + FunctionFragment, + Result, + Interface, + EventFragment, + AddressLike, + ContractRunner, + ContractMethod, + Listener, +} from "ethers"; +import type { + TypedContractEvent, + TypedDeferredTopicFilter, + TypedEventLog, + TypedLogDescription, + TypedListener, + TypedContractMethod, +} from "./common"; + +export declare namespace INonfungiblePositionManager { + export type CollectParamsStruct = { + tokenId: BigNumberish; + recipient: AddressLike; + amount0Max: BigNumberish; + amount1Max: BigNumberish; + }; + + export type CollectParamsStructOutput = [ + tokenId: bigint, + recipient: string, + amount0Max: bigint, + amount1Max: bigint + ] & { + tokenId: bigint; + recipient: string; + amount0Max: bigint; + amount1Max: bigint; + }; + + export type DecreaseLiquidityParamsStruct = { + tokenId: BigNumberish; + liquidity: BigNumberish; + amount0Min: BigNumberish; + amount1Min: BigNumberish; + deadline: BigNumberish; + }; + + export type DecreaseLiquidityParamsStructOutput = [ + tokenId: bigint, + liquidity: bigint, + amount0Min: bigint, + amount1Min: bigint, + deadline: bigint + ] & { + tokenId: bigint; + liquidity: bigint; + amount0Min: bigint; + amount1Min: bigint; + deadline: bigint; + }; + + export type IncreaseLiquidityParamsStruct = { + tokenId: BigNumberish; + amount0Desired: BigNumberish; + amount1Desired: BigNumberish; + amount0Min: BigNumberish; + amount1Min: BigNumberish; + deadline: BigNumberish; + }; + + export type IncreaseLiquidityParamsStructOutput = [ + tokenId: bigint, + amount0Desired: bigint, + amount1Desired: bigint, + amount0Min: bigint, + amount1Min: bigint, + deadline: bigint + ] & { + tokenId: bigint; + amount0Desired: bigint; + amount1Desired: bigint; + amount0Min: bigint; + amount1Min: bigint; + deadline: bigint; + }; + + export type MintParamsStruct = { + token0: AddressLike; + token1: AddressLike; + tickLower: BigNumberish; + tickUpper: BigNumberish; + amount0Desired: BigNumberish; + amount1Desired: BigNumberish; + amount0Min: BigNumberish; + amount1Min: BigNumberish; + recipient: AddressLike; + deadline: BigNumberish; + }; + + export type MintParamsStructOutput = [ + token0: string, + token1: string, + tickLower: bigint, + tickUpper: bigint, + amount0Desired: bigint, + amount1Desired: bigint, + amount0Min: bigint, + amount1Min: bigint, + recipient: string, + deadline: bigint + ] & { + token0: string; + token1: string; + tickLower: bigint; + tickUpper: bigint; + amount0Desired: bigint; + amount1Desired: bigint; + amount0Min: bigint; + amount1Min: bigint; + recipient: string; + deadline: bigint; + }; +} + +export interface PositionManagerInterface extends Interface { + getFunction( + nameOrSignature: + | "DOMAIN_SEPARATOR" + | "PERMIT_TYPEHASH" + | "WNativeToken" + | "algebraMintCallback" + | "approve" + | "balanceOf" + | "baseURI" + | "burn" + | "collect" + | "createAndInitializePoolIfNecessary" + | "decreaseLiquidity" + | "factory" + | "getApproved" + | "increaseLiquidity" + | "isApprovedForAll" + | "mint" + | "multicall" + | "name" + | "ownerOf" + | "permit" + | "poolDeployer" + | "positions" + | "refundNativeToken" + | "safeTransferFrom(address,address,uint256)" + | "safeTransferFrom(address,address,uint256,bytes)" + | "selfPermit" + | "selfPermitAllowed" + | "selfPermitAllowedIfNecessary" + | "selfPermitIfNecessary" + | "setApprovalForAll" + | "supportsInterface" + | "sweepToken" + | "symbol" + | "tokenByIndex" + | "tokenOfOwnerByIndex" + | "tokenURI" + | "totalSupply" + | "transferFrom" + | "unwrapWNativeToken" + ): FunctionFragment; + + getEvent( + nameOrSignatureOrTopic: + | "Approval" + | "ApprovalForAll" + | "Collect" + | "DecreaseLiquidity" + | "IncreaseLiquidity" + | "Transfer" + ): EventFragment; + + encodeFunctionData( + functionFragment: "DOMAIN_SEPARATOR", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "PERMIT_TYPEHASH", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "WNativeToken", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "algebraMintCallback", + values: [BigNumberish, BigNumberish, BytesLike] + ): string; + encodeFunctionData( + functionFragment: "approve", + values: [AddressLike, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "balanceOf", + values: [AddressLike] + ): string; + encodeFunctionData(functionFragment: "baseURI", values?: undefined): string; + encodeFunctionData(functionFragment: "burn", values: [BigNumberish]): string; + encodeFunctionData( + functionFragment: "collect", + values: [INonfungiblePositionManager.CollectParamsStruct] + ): string; + encodeFunctionData( + functionFragment: "createAndInitializePoolIfNecessary", + values: [AddressLike, AddressLike, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "decreaseLiquidity", + values: [INonfungiblePositionManager.DecreaseLiquidityParamsStruct] + ): string; + encodeFunctionData(functionFragment: "factory", values?: undefined): string; + encodeFunctionData( + functionFragment: "getApproved", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "increaseLiquidity", + values: [INonfungiblePositionManager.IncreaseLiquidityParamsStruct] + ): string; + encodeFunctionData( + functionFragment: "isApprovedForAll", + values: [AddressLike, AddressLike] + ): string; + encodeFunctionData( + functionFragment: "mint", + values: [INonfungiblePositionManager.MintParamsStruct] + ): string; + encodeFunctionData( + functionFragment: "multicall", + values: [BytesLike[]] + ): string; + encodeFunctionData(functionFragment: "name", values?: undefined): string; + encodeFunctionData( + functionFragment: "ownerOf", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "permit", + values: [ + AddressLike, + BigNumberish, + BigNumberish, + BigNumberish, + BytesLike, + BytesLike + ] + ): string; + encodeFunctionData( + functionFragment: "poolDeployer", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "positions", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "refundNativeToken", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "safeTransferFrom(address,address,uint256)", + values: [AddressLike, AddressLike, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "safeTransferFrom(address,address,uint256,bytes)", + values: [AddressLike, AddressLike, BigNumberish, BytesLike] + ): string; + encodeFunctionData( + functionFragment: "selfPermit", + values: [ + AddressLike, + BigNumberish, + BigNumberish, + BigNumberish, + BytesLike, + BytesLike + ] + ): string; + encodeFunctionData( + functionFragment: "selfPermitAllowed", + values: [ + AddressLike, + BigNumberish, + BigNumberish, + BigNumberish, + BytesLike, + BytesLike + ] + ): string; + encodeFunctionData( + functionFragment: "selfPermitAllowedIfNecessary", + values: [ + AddressLike, + BigNumberish, + BigNumberish, + BigNumberish, + BytesLike, + BytesLike + ] + ): string; + encodeFunctionData( + functionFragment: "selfPermitIfNecessary", + values: [ + AddressLike, + BigNumberish, + BigNumberish, + BigNumberish, + BytesLike, + BytesLike + ] + ): string; + encodeFunctionData( + functionFragment: "setApprovalForAll", + values: [AddressLike, boolean] + ): string; + encodeFunctionData( + functionFragment: "supportsInterface", + values: [BytesLike] + ): string; + encodeFunctionData( + functionFragment: "sweepToken", + values: [AddressLike, BigNumberish, AddressLike] + ): string; + encodeFunctionData(functionFragment: "symbol", values?: undefined): string; + encodeFunctionData( + functionFragment: "tokenByIndex", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "tokenOfOwnerByIndex", + values: [AddressLike, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "tokenURI", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "totalSupply", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "transferFrom", + values: [AddressLike, AddressLike, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "unwrapWNativeToken", + values: [BigNumberish, AddressLike] + ): string; + + decodeFunctionResult( + functionFragment: "DOMAIN_SEPARATOR", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "PERMIT_TYPEHASH", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "WNativeToken", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "algebraMintCallback", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "baseURI", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "burn", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "collect", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "createAndInitializePoolIfNecessary", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "decreaseLiquidity", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "factory", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "getApproved", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "increaseLiquidity", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "isApprovedForAll", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "mint", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "multicall", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "name", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "ownerOf", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "permit", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "poolDeployer", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "positions", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "refundNativeToken", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "safeTransferFrom(address,address,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "safeTransferFrom(address,address,uint256,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "selfPermit", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "selfPermitAllowed", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "selfPermitAllowedIfNecessary", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "selfPermitIfNecessary", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "setApprovalForAll", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "supportsInterface", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "sweepToken", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "tokenByIndex", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "tokenOfOwnerByIndex", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "tokenURI", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "totalSupply", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "transferFrom", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "unwrapWNativeToken", + data: BytesLike + ): Result; +} + +export namespace ApprovalEvent { + export type InputTuple = [ + owner: AddressLike, + approved: AddressLike, + tokenId: BigNumberish + ]; + export type OutputTuple = [owner: string, approved: string, tokenId: bigint]; + export interface OutputObject { + owner: string; + approved: string; + tokenId: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace ApprovalForAllEvent { + export type InputTuple = [ + owner: AddressLike, + operator: AddressLike, + approved: boolean + ]; + export type OutputTuple = [ + owner: string, + operator: string, + approved: boolean + ]; + export interface OutputObject { + owner: string; + operator: string; + approved: boolean; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace CollectEvent { + export type InputTuple = [ + tokenId: BigNumberish, + recipient: AddressLike, + amount0: BigNumberish, + amount1: BigNumberish + ]; + export type OutputTuple = [ + tokenId: bigint, + recipient: string, + amount0: bigint, + amount1: bigint + ]; + export interface OutputObject { + tokenId: bigint; + recipient: string; + amount0: bigint; + amount1: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace DecreaseLiquidityEvent { + export type InputTuple = [ + tokenId: BigNumberish, + liquidity: BigNumberish, + amount0: BigNumberish, + amount1: BigNumberish + ]; + export type OutputTuple = [ + tokenId: bigint, + liquidity: bigint, + amount0: bigint, + amount1: bigint + ]; + export interface OutputObject { + tokenId: bigint; + liquidity: bigint; + amount0: bigint; + amount1: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace IncreaseLiquidityEvent { + export type InputTuple = [ + tokenId: BigNumberish, + liquidity: BigNumberish, + actualLiquidity: BigNumberish, + amount0: BigNumberish, + amount1: BigNumberish, + pool: AddressLike + ]; + export type OutputTuple = [ + tokenId: bigint, + liquidity: bigint, + actualLiquidity: bigint, + amount0: bigint, + amount1: bigint, + pool: string + ]; + export interface OutputObject { + tokenId: bigint; + liquidity: bigint; + actualLiquidity: bigint; + amount0: bigint; + amount1: bigint; + pool: string; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace TransferEvent { + export type InputTuple = [ + from: AddressLike, + to: AddressLike, + tokenId: BigNumberish + ]; + export type OutputTuple = [from: string, to: string, tokenId: bigint]; + export interface OutputObject { + from: string; + to: string; + tokenId: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export interface PositionManager extends BaseContract { + connect(runner?: ContractRunner | null): PositionManager; + waitForDeployment(): Promise; + + interface: PositionManagerInterface; + + queryFilter( + event: TCEvent, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>>; + queryFilter( + filter: TypedDeferredTopicFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>>; + + on( + event: TCEvent, + listener: TypedListener + ): Promise; + on( + filter: TypedDeferredTopicFilter, + listener: TypedListener + ): Promise; + + once( + event: TCEvent, + listener: TypedListener + ): Promise; + once( + filter: TypedDeferredTopicFilter, + listener: TypedListener + ): Promise; + + listeners( + event: TCEvent + ): Promise>>; + listeners(eventName?: string): Promise>; + removeAllListeners( + event?: TCEvent + ): Promise; + + DOMAIN_SEPARATOR: TypedContractMethod<[], [string], "view">; + + PERMIT_TYPEHASH: TypedContractMethod<[], [string], "view">; + + WNativeToken: TypedContractMethod<[], [string], "view">; + + algebraMintCallback: TypedContractMethod< + [amount0Owed: BigNumberish, amount1Owed: BigNumberish, data: BytesLike], + [void], + "nonpayable" + >; + + approve: TypedContractMethod< + [to: AddressLike, tokenId: BigNumberish], + [void], + "nonpayable" + >; + + balanceOf: TypedContractMethod<[owner: AddressLike], [bigint], "view">; + + baseURI: TypedContractMethod<[], [string], "view">; + + burn: TypedContractMethod<[tokenId: BigNumberish], [void], "payable">; + + collect: TypedContractMethod< + [params: INonfungiblePositionManager.CollectParamsStruct], + [[bigint, bigint] & { amount0: bigint; amount1: bigint }], + "payable" + >; + + createAndInitializePoolIfNecessary: TypedContractMethod< + [token0: AddressLike, token1: AddressLike, sqrtPriceX96: BigNumberish], + [string], + "payable" + >; + + decreaseLiquidity: TypedContractMethod< + [params: INonfungiblePositionManager.DecreaseLiquidityParamsStruct], + [[bigint, bigint] & { amount0: bigint; amount1: bigint }], + "payable" + >; + + factory: TypedContractMethod<[], [string], "view">; + + getApproved: TypedContractMethod<[tokenId: BigNumberish], [string], "view">; + + increaseLiquidity: TypedContractMethod< + [params: INonfungiblePositionManager.IncreaseLiquidityParamsStruct], + [ + [bigint, bigint, bigint] & { + liquidity: bigint; + amount0: bigint; + amount1: bigint; + } + ], + "payable" + >; + + isApprovedForAll: TypedContractMethod< + [owner: AddressLike, operator: AddressLike], + [boolean], + "view" + >; + + mint: TypedContractMethod< + [params: INonfungiblePositionManager.MintParamsStruct], + [ + [bigint, bigint, bigint, bigint] & { + tokenId: bigint; + liquidity: bigint; + amount0: bigint; + amount1: bigint; + } + ], + "payable" + >; + + multicall: TypedContractMethod<[data: BytesLike[]], [string[]], "payable">; + + name: TypedContractMethod<[], [string], "view">; + + ownerOf: TypedContractMethod<[tokenId: BigNumberish], [string], "view">; + + permit: TypedContractMethod< + [ + spender: AddressLike, + tokenId: BigNumberish, + deadline: BigNumberish, + v: BigNumberish, + r: BytesLike, + s: BytesLike + ], + [void], + "payable" + >; + + poolDeployer: TypedContractMethod<[], [string], "view">; + + positions: TypedContractMethod< + [tokenId: BigNumberish], + [ + [ + bigint, + string, + string, + string, + bigint, + bigint, + bigint, + bigint, + bigint, + bigint, + bigint + ] & { + nonce: bigint; + operator: string; + token0: string; + token1: string; + tickLower: bigint; + tickUpper: bigint; + liquidity: bigint; + feeGrowthInside0LastX128: bigint; + feeGrowthInside1LastX128: bigint; + tokensOwed0: bigint; + tokensOwed1: bigint; + } + ], + "view" + >; + + refundNativeToken: TypedContractMethod<[], [void], "payable">; + + "safeTransferFrom(address,address,uint256)": TypedContractMethod< + [from: AddressLike, to: AddressLike, tokenId: BigNumberish], + [void], + "nonpayable" + >; + + "safeTransferFrom(address,address,uint256,bytes)": TypedContractMethod< + [ + from: AddressLike, + to: AddressLike, + tokenId: BigNumberish, + _data: BytesLike + ], + [void], + "nonpayable" + >; + + selfPermit: TypedContractMethod< + [ + token: AddressLike, + value: BigNumberish, + deadline: BigNumberish, + v: BigNumberish, + r: BytesLike, + s: BytesLike + ], + [void], + "payable" + >; + + selfPermitAllowed: TypedContractMethod< + [ + token: AddressLike, + nonce: BigNumberish, + expiry: BigNumberish, + v: BigNumberish, + r: BytesLike, + s: BytesLike + ], + [void], + "payable" + >; + + selfPermitAllowedIfNecessary: TypedContractMethod< + [ + token: AddressLike, + nonce: BigNumberish, + expiry: BigNumberish, + v: BigNumberish, + r: BytesLike, + s: BytesLike + ], + [void], + "payable" + >; + + selfPermitIfNecessary: TypedContractMethod< + [ + token: AddressLike, + value: BigNumberish, + deadline: BigNumberish, + v: BigNumberish, + r: BytesLike, + s: BytesLike + ], + [void], + "payable" + >; + + setApprovalForAll: TypedContractMethod< + [operator: AddressLike, approved: boolean], + [void], + "nonpayable" + >; + + supportsInterface: TypedContractMethod< + [interfaceId: BytesLike], + [boolean], + "view" + >; + + sweepToken: TypedContractMethod< + [token: AddressLike, amountMinimum: BigNumberish, recipient: AddressLike], + [void], + "payable" + >; + + symbol: TypedContractMethod<[], [string], "view">; + + tokenByIndex: TypedContractMethod<[index: BigNumberish], [bigint], "view">; + + tokenOfOwnerByIndex: TypedContractMethod< + [owner: AddressLike, index: BigNumberish], + [bigint], + "view" + >; + + tokenURI: TypedContractMethod<[tokenId: BigNumberish], [string], "view">; + + totalSupply: TypedContractMethod<[], [bigint], "view">; + + transferFrom: TypedContractMethod< + [from: AddressLike, to: AddressLike, tokenId: BigNumberish], + [void], + "nonpayable" + >; + + unwrapWNativeToken: TypedContractMethod< + [amountMinimum: BigNumberish, recipient: AddressLike], + [void], + "payable" + >; + + getFunction( + key: string | FunctionFragment + ): T; + + getFunction( + nameOrSignature: "DOMAIN_SEPARATOR" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "PERMIT_TYPEHASH" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "WNativeToken" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "algebraMintCallback" + ): TypedContractMethod< + [amount0Owed: BigNumberish, amount1Owed: BigNumberish, data: BytesLike], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "approve" + ): TypedContractMethod< + [to: AddressLike, tokenId: BigNumberish], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "balanceOf" + ): TypedContractMethod<[owner: AddressLike], [bigint], "view">; + getFunction( + nameOrSignature: "baseURI" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "burn" + ): TypedContractMethod<[tokenId: BigNumberish], [void], "payable">; + getFunction( + nameOrSignature: "collect" + ): TypedContractMethod< + [params: INonfungiblePositionManager.CollectParamsStruct], + [[bigint, bigint] & { amount0: bigint; amount1: bigint }], + "payable" + >; + getFunction( + nameOrSignature: "createAndInitializePoolIfNecessary" + ): TypedContractMethod< + [token0: AddressLike, token1: AddressLike, sqrtPriceX96: BigNumberish], + [string], + "payable" + >; + getFunction( + nameOrSignature: "decreaseLiquidity" + ): TypedContractMethod< + [params: INonfungiblePositionManager.DecreaseLiquidityParamsStruct], + [[bigint, bigint] & { amount0: bigint; amount1: bigint }], + "payable" + >; + getFunction( + nameOrSignature: "factory" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "getApproved" + ): TypedContractMethod<[tokenId: BigNumberish], [string], "view">; + getFunction( + nameOrSignature: "increaseLiquidity" + ): TypedContractMethod< + [params: INonfungiblePositionManager.IncreaseLiquidityParamsStruct], + [ + [bigint, bigint, bigint] & { + liquidity: bigint; + amount0: bigint; + amount1: bigint; + } + ], + "payable" + >; + getFunction( + nameOrSignature: "isApprovedForAll" + ): TypedContractMethod< + [owner: AddressLike, operator: AddressLike], + [boolean], + "view" + >; + getFunction( + nameOrSignature: "mint" + ): TypedContractMethod< + [params: INonfungiblePositionManager.MintParamsStruct], + [ + [bigint, bigint, bigint, bigint] & { + tokenId: bigint; + liquidity: bigint; + amount0: bigint; + amount1: bigint; + } + ], + "payable" + >; + getFunction( + nameOrSignature: "multicall" + ): TypedContractMethod<[data: BytesLike[]], [string[]], "payable">; + getFunction( + nameOrSignature: "name" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "ownerOf" + ): TypedContractMethod<[tokenId: BigNumberish], [string], "view">; + getFunction( + nameOrSignature: "permit" + ): TypedContractMethod< + [ + spender: AddressLike, + tokenId: BigNumberish, + deadline: BigNumberish, + v: BigNumberish, + r: BytesLike, + s: BytesLike + ], + [void], + "payable" + >; + getFunction( + nameOrSignature: "poolDeployer" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "positions" + ): TypedContractMethod< + [tokenId: BigNumberish], + [ + [ + bigint, + string, + string, + string, + bigint, + bigint, + bigint, + bigint, + bigint, + bigint, + bigint + ] & { + nonce: bigint; + operator: string; + token0: string; + token1: string; + tickLower: bigint; + tickUpper: bigint; + liquidity: bigint; + feeGrowthInside0LastX128: bigint; + feeGrowthInside1LastX128: bigint; + tokensOwed0: bigint; + tokensOwed1: bigint; + } + ], + "view" + >; + getFunction( + nameOrSignature: "refundNativeToken" + ): TypedContractMethod<[], [void], "payable">; + getFunction( + nameOrSignature: "safeTransferFrom(address,address,uint256)" + ): TypedContractMethod< + [from: AddressLike, to: AddressLike, tokenId: BigNumberish], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "safeTransferFrom(address,address,uint256,bytes)" + ): TypedContractMethod< + [ + from: AddressLike, + to: AddressLike, + tokenId: BigNumberish, + _data: BytesLike + ], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "selfPermit" + ): TypedContractMethod< + [ + token: AddressLike, + value: BigNumberish, + deadline: BigNumberish, + v: BigNumberish, + r: BytesLike, + s: BytesLike + ], + [void], + "payable" + >; + getFunction( + nameOrSignature: "selfPermitAllowed" + ): TypedContractMethod< + [ + token: AddressLike, + nonce: BigNumberish, + expiry: BigNumberish, + v: BigNumberish, + r: BytesLike, + s: BytesLike + ], + [void], + "payable" + >; + getFunction( + nameOrSignature: "selfPermitAllowedIfNecessary" + ): TypedContractMethod< + [ + token: AddressLike, + nonce: BigNumberish, + expiry: BigNumberish, + v: BigNumberish, + r: BytesLike, + s: BytesLike + ], + [void], + "payable" + >; + getFunction( + nameOrSignature: "selfPermitIfNecessary" + ): TypedContractMethod< + [ + token: AddressLike, + value: BigNumberish, + deadline: BigNumberish, + v: BigNumberish, + r: BytesLike, + s: BytesLike + ], + [void], + "payable" + >; + getFunction( + nameOrSignature: "setApprovalForAll" + ): TypedContractMethod< + [operator: AddressLike, approved: boolean], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "supportsInterface" + ): TypedContractMethod<[interfaceId: BytesLike], [boolean], "view">; + getFunction( + nameOrSignature: "sweepToken" + ): TypedContractMethod< + [token: AddressLike, amountMinimum: BigNumberish, recipient: AddressLike], + [void], + "payable" + >; + getFunction( + nameOrSignature: "symbol" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "tokenByIndex" + ): TypedContractMethod<[index: BigNumberish], [bigint], "view">; + getFunction( + nameOrSignature: "tokenOfOwnerByIndex" + ): TypedContractMethod< + [owner: AddressLike, index: BigNumberish], + [bigint], + "view" + >; + getFunction( + nameOrSignature: "tokenURI" + ): TypedContractMethod<[tokenId: BigNumberish], [string], "view">; + getFunction( + nameOrSignature: "totalSupply" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "transferFrom" + ): TypedContractMethod< + [from: AddressLike, to: AddressLike, tokenId: BigNumberish], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "unwrapWNativeToken" + ): TypedContractMethod< + [amountMinimum: BigNumberish, recipient: AddressLike], + [void], + "payable" + >; + + getEvent( + key: "Approval" + ): TypedContractEvent< + ApprovalEvent.InputTuple, + ApprovalEvent.OutputTuple, + ApprovalEvent.OutputObject + >; + getEvent( + key: "ApprovalForAll" + ): TypedContractEvent< + ApprovalForAllEvent.InputTuple, + ApprovalForAllEvent.OutputTuple, + ApprovalForAllEvent.OutputObject + >; + getEvent( + key: "Collect" + ): TypedContractEvent< + CollectEvent.InputTuple, + CollectEvent.OutputTuple, + CollectEvent.OutputObject + >; + getEvent( + key: "DecreaseLiquidity" + ): TypedContractEvent< + DecreaseLiquidityEvent.InputTuple, + DecreaseLiquidityEvent.OutputTuple, + DecreaseLiquidityEvent.OutputObject + >; + getEvent( + key: "IncreaseLiquidity" + ): TypedContractEvent< + IncreaseLiquidityEvent.InputTuple, + IncreaseLiquidityEvent.OutputTuple, + IncreaseLiquidityEvent.OutputObject + >; + getEvent( + key: "Transfer" + ): TypedContractEvent< + TransferEvent.InputTuple, + TransferEvent.OutputTuple, + TransferEvent.OutputObject + >; + + filters: { + "Approval(address,address,uint256)": TypedContractEvent< + ApprovalEvent.InputTuple, + ApprovalEvent.OutputTuple, + ApprovalEvent.OutputObject + >; + Approval: TypedContractEvent< + ApprovalEvent.InputTuple, + ApprovalEvent.OutputTuple, + ApprovalEvent.OutputObject + >; + + "ApprovalForAll(address,address,bool)": TypedContractEvent< + ApprovalForAllEvent.InputTuple, + ApprovalForAllEvent.OutputTuple, + ApprovalForAllEvent.OutputObject + >; + ApprovalForAll: TypedContractEvent< + ApprovalForAllEvent.InputTuple, + ApprovalForAllEvent.OutputTuple, + ApprovalForAllEvent.OutputObject + >; + + "Collect(uint256,address,uint256,uint256)": TypedContractEvent< + CollectEvent.InputTuple, + CollectEvent.OutputTuple, + CollectEvent.OutputObject + >; + Collect: TypedContractEvent< + CollectEvent.InputTuple, + CollectEvent.OutputTuple, + CollectEvent.OutputObject + >; + + "DecreaseLiquidity(uint256,uint128,uint256,uint256)": TypedContractEvent< + DecreaseLiquidityEvent.InputTuple, + DecreaseLiquidityEvent.OutputTuple, + DecreaseLiquidityEvent.OutputObject + >; + DecreaseLiquidity: TypedContractEvent< + DecreaseLiquidityEvent.InputTuple, + DecreaseLiquidityEvent.OutputTuple, + DecreaseLiquidityEvent.OutputObject + >; + + "IncreaseLiquidity(uint256,uint128,uint128,uint256,uint256,address)": TypedContractEvent< + IncreaseLiquidityEvent.InputTuple, + IncreaseLiquidityEvent.OutputTuple, + IncreaseLiquidityEvent.OutputObject + >; + IncreaseLiquidity: TypedContractEvent< + IncreaseLiquidityEvent.InputTuple, + IncreaseLiquidityEvent.OutputTuple, + IncreaseLiquidityEvent.OutputObject + >; + + "Transfer(address,address,uint256)": TypedContractEvent< + TransferEvent.InputTuple, + TransferEvent.OutputTuple, + TransferEvent.OutputObject + >; + Transfer: TypedContractEvent< + TransferEvent.InputTuple, + TransferEvent.OutputTuple, + TransferEvent.OutputObject + >; + }; +} diff --git a/packages/adapters-library/src/adapters/quickswap-v3/contracts/abis/position-manager.json b/packages/adapters-library/src/adapters/quickswap-v3/contracts/abis/position-manager.json new file mode 100644 index 000000000..528b42874 --- /dev/null +++ b/packages/adapters-library/src/adapters/quickswap-v3/contracts/abis/position-manager.json @@ -0,0 +1 @@ +[{"inputs":[{"internalType":"address","name":"_factory","type":"address"},{"internalType":"address","name":"_WNativeToken","type":"address"},{"internalType":"address","name":"_tokenDescriptor_","type":"address"},{"internalType":"address","name":"_poolDeployer","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount0","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount1","type":"uint256"}],"name":"Collect","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint128","name":"liquidity","type":"uint128"},{"indexed":false,"internalType":"uint256","name":"amount0","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount1","type":"uint256"}],"name":"DecreaseLiquidity","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint128","name":"liquidity","type":"uint128"},{"indexed":false,"internalType":"uint128","name":"actualLiquidity","type":"uint128"},{"indexed":false,"internalType":"uint256","name":"amount0","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount1","type":"uint256"},{"indexed":false,"internalType":"address","name":"pool","type":"address"}],"name":"IncreaseLiquidity","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERMIT_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WNativeToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount0Owed","type":"uint256"},{"internalType":"uint256","name":"amount1Owed","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"algebraMintCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint128","name":"amount0Max","type":"uint128"},{"internalType":"uint128","name":"amount1Max","type":"uint128"}],"internalType":"struct INonfungiblePositionManager.CollectParams","name":"params","type":"tuple"}],"name":"collect","outputs":[{"internalType":"uint256","name":"amount0","type":"uint256"},{"internalType":"uint256","name":"amount1","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"uint160","name":"sqrtPriceX96","type":"uint160"}],"name":"createAndInitializePoolIfNecessary","outputs":[{"internalType":"address","name":"pool","type":"address"}],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint128","name":"liquidity","type":"uint128"},{"internalType":"uint256","name":"amount0Min","type":"uint256"},{"internalType":"uint256","name":"amount1Min","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"internalType":"struct INonfungiblePositionManager.DecreaseLiquidityParams","name":"params","type":"tuple"}],"name":"decreaseLiquidity","outputs":[{"internalType":"uint256","name":"amount0","type":"uint256"},{"internalType":"uint256","name":"amount1","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"factory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"amount0Desired","type":"uint256"},{"internalType":"uint256","name":"amount1Desired","type":"uint256"},{"internalType":"uint256","name":"amount0Min","type":"uint256"},{"internalType":"uint256","name":"amount1Min","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"internalType":"struct INonfungiblePositionManager.IncreaseLiquidityParams","name":"params","type":"tuple"}],"name":"increaseLiquidity","outputs":[{"internalType":"uint128","name":"liquidity","type":"uint128"},{"internalType":"uint256","name":"amount0","type":"uint256"},{"internalType":"uint256","name":"amount1","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"int24","name":"tickLower","type":"int24"},{"internalType":"int24","name":"tickUpper","type":"int24"},{"internalType":"uint256","name":"amount0Desired","type":"uint256"},{"internalType":"uint256","name":"amount1Desired","type":"uint256"},{"internalType":"uint256","name":"amount0Min","type":"uint256"},{"internalType":"uint256","name":"amount1Min","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"internalType":"struct INonfungiblePositionManager.MintParams","name":"params","type":"tuple"}],"name":"mint","outputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint128","name":"liquidity","type":"uint128"},{"internalType":"uint256","name":"amount0","type":"uint256"},{"internalType":"uint256","name":"amount1","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"results","type":"bytes[]"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"poolDeployer","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"positions","outputs":[{"internalType":"uint96","name":"nonce","type":"uint96"},{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"int24","name":"tickLower","type":"int24"},{"internalType":"int24","name":"tickUpper","type":"int24"},{"internalType":"uint128","name":"liquidity","type":"uint128"},{"internalType":"uint256","name":"feeGrowthInside0LastX128","type":"uint256"},{"internalType":"uint256","name":"feeGrowthInside1LastX128","type":"uint256"},{"internalType":"uint128","name":"tokensOwed0","type":"uint128"},{"internalType":"uint128","name":"tokensOwed1","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"refundNativeToken","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"selfPermit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"selfPermitAllowed","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"selfPermitAllowedIfNecessary","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"selfPermitIfNecessary","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amountMinimum","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"}],"name":"sweepToken","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountMinimum","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"}],"name":"unwrapWNativeToken","outputs":[],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}] \ No newline at end of file diff --git a/packages/adapters-library/src/adapters/quickswap-v3/contracts/common.ts b/packages/adapters-library/src/adapters/quickswap-v3/contracts/common.ts new file mode 100644 index 000000000..56b5f21e9 --- /dev/null +++ b/packages/adapters-library/src/adapters/quickswap-v3/contracts/common.ts @@ -0,0 +1,131 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + FunctionFragment, + Typed, + EventFragment, + ContractTransaction, + ContractTransactionResponse, + DeferredTopicFilter, + EventLog, + TransactionRequest, + LogDescription, +} from "ethers"; + +export interface TypedDeferredTopicFilter<_TCEvent extends TypedContractEvent> + extends DeferredTopicFilter {} + +export interface TypedContractEvent< + InputTuple extends Array = any, + OutputTuple extends Array = any, + OutputObject = any +> { + (...args: Partial): TypedDeferredTopicFilter< + TypedContractEvent + >; + name: string; + fragment: EventFragment; + getFragment(...args: Partial): EventFragment; +} + +type __TypechainAOutputTuple = T extends TypedContractEvent< + infer _U, + infer W +> + ? W + : never; +type __TypechainOutputObject = T extends TypedContractEvent< + infer _U, + infer _W, + infer V +> + ? V + : never; + +export interface TypedEventLog + extends Omit { + args: __TypechainAOutputTuple & __TypechainOutputObject; +} + +export interface TypedLogDescription + extends Omit { + args: __TypechainAOutputTuple & __TypechainOutputObject; +} + +export type TypedListener = ( + ...listenerArg: [ + ...__TypechainAOutputTuple, + TypedEventLog, + ...undefined[] + ] +) => void; + +export type MinEthersFactory = { + deploy(...a: ARGS[]): Promise; +}; + +export type GetContractTypeFromFactory = F extends MinEthersFactory< + infer C, + any +> + ? C + : never; +export type GetARGsTypeFromFactory = F extends MinEthersFactory + ? Parameters + : never; + +export type StateMutability = "nonpayable" | "payable" | "view"; + +export type BaseOverrides = Omit; +export type NonPayableOverrides = Omit< + BaseOverrides, + "value" | "blockTag" | "enableCcipRead" +>; +export type PayableOverrides = Omit< + BaseOverrides, + "blockTag" | "enableCcipRead" +>; +export type ViewOverrides = Omit; +export type Overrides = S extends "nonpayable" + ? NonPayableOverrides + : S extends "payable" + ? PayableOverrides + : ViewOverrides; + +export type PostfixOverrides, S extends StateMutability> = + | A + | [...A, Overrides]; +export type ContractMethodArgs< + A extends Array, + S extends StateMutability +> = PostfixOverrides<{ [I in keyof A]-?: A[I] | Typed }, S>; + +export type DefaultReturnType = R extends Array ? R[0] : R; + +// export interface ContractMethod = Array, R = any, D extends R | ContractTransactionResponse = R | ContractTransactionResponse> { +export interface TypedContractMethod< + A extends Array = Array, + R = any, + S extends StateMutability = "payable" +> { + (...args: ContractMethodArgs): S extends "view" + ? Promise> + : Promise; + + name: string; + + fragment: FunctionFragment; + + getFragment(...args: ContractMethodArgs): FunctionFragment; + + populateTransaction( + ...args: ContractMethodArgs + ): Promise; + staticCall( + ...args: ContractMethodArgs + ): Promise>; + send(...args: ContractMethodArgs): Promise; + estimateGas(...args: ContractMethodArgs): Promise; + staticCallResult(...args: ContractMethodArgs): Promise; +} diff --git a/packages/adapters-library/src/adapters/quickswap-v3/contracts/factories/PositionManager__factory.ts b/packages/adapters-library/src/adapters/quickswap-v3/contracts/factories/PositionManager__factory.ts new file mode 100644 index 000000000..49f871eb0 --- /dev/null +++ b/packages/adapters-library/src/adapters/quickswap-v3/contracts/factories/PositionManager__factory.ts @@ -0,0 +1,1261 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Interface, type ContractRunner } from "ethers"; +import type { + PositionManager, + PositionManagerInterface, +} from "../PositionManager"; + +const _abi = [ + { + inputs: [ + { + internalType: "address", + name: "_factory", + type: "address", + }, + { + internalType: "address", + name: "_WNativeToken", + type: "address", + }, + { + internalType: "address", + name: "_tokenDescriptor_", + type: "address", + }, + { + internalType: "address", + name: "_poolDeployer", + type: "address", + }, + ], + stateMutability: "nonpayable", + type: "constructor", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "owner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "approved", + type: "address", + }, + { + indexed: true, + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + ], + name: "Approval", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "owner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "operator", + type: "address", + }, + { + indexed: false, + internalType: "bool", + name: "approved", + type: "bool", + }, + ], + name: "ApprovalForAll", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + { + indexed: false, + internalType: "address", + name: "recipient", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount0", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "amount1", + type: "uint256", + }, + ], + name: "Collect", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + { + indexed: false, + internalType: "uint128", + name: "liquidity", + type: "uint128", + }, + { + indexed: false, + internalType: "uint256", + name: "amount0", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "amount1", + type: "uint256", + }, + ], + name: "DecreaseLiquidity", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + { + indexed: false, + internalType: "uint128", + name: "liquidity", + type: "uint128", + }, + { + indexed: false, + internalType: "uint128", + name: "actualLiquidity", + type: "uint128", + }, + { + indexed: false, + internalType: "uint256", + name: "amount0", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "amount1", + type: "uint256", + }, + { + indexed: false, + internalType: "address", + name: "pool", + type: "address", + }, + ], + name: "IncreaseLiquidity", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "from", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: true, + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + ], + name: "Transfer", + type: "event", + }, + { + inputs: [], + name: "DOMAIN_SEPARATOR", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "PERMIT_TYPEHASH", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "WNativeToken", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "amount0Owed", + type: "uint256", + }, + { + internalType: "uint256", + name: "amount1Owed", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "algebraMintCallback", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + ], + name: "approve", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "owner", + type: "address", + }, + ], + name: "balanceOf", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "baseURI", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + ], + name: "burn", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + components: [ + { + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + { + internalType: "address", + name: "recipient", + type: "address", + }, + { + internalType: "uint128", + name: "amount0Max", + type: "uint128", + }, + { + internalType: "uint128", + name: "amount1Max", + type: "uint128", + }, + ], + internalType: "struct INonfungiblePositionManager.CollectParams", + name: "params", + type: "tuple", + }, + ], + name: "collect", + outputs: [ + { + internalType: "uint256", + name: "amount0", + type: "uint256", + }, + { + internalType: "uint256", + name: "amount1", + type: "uint256", + }, + ], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token0", + type: "address", + }, + { + internalType: "address", + name: "token1", + type: "address", + }, + { + internalType: "uint160", + name: "sqrtPriceX96", + type: "uint160", + }, + ], + name: "createAndInitializePoolIfNecessary", + outputs: [ + { + internalType: "address", + name: "pool", + type: "address", + }, + ], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + components: [ + { + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + { + internalType: "uint128", + name: "liquidity", + type: "uint128", + }, + { + internalType: "uint256", + name: "amount0Min", + type: "uint256", + }, + { + internalType: "uint256", + name: "amount1Min", + type: "uint256", + }, + { + internalType: "uint256", + name: "deadline", + type: "uint256", + }, + ], + internalType: + "struct INonfungiblePositionManager.DecreaseLiquidityParams", + name: "params", + type: "tuple", + }, + ], + name: "decreaseLiquidity", + outputs: [ + { + internalType: "uint256", + name: "amount0", + type: "uint256", + }, + { + internalType: "uint256", + name: "amount1", + type: "uint256", + }, + ], + stateMutability: "payable", + type: "function", + }, + { + inputs: [], + name: "factory", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + ], + name: "getApproved", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + components: [ + { + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + { + internalType: "uint256", + name: "amount0Desired", + type: "uint256", + }, + { + internalType: "uint256", + name: "amount1Desired", + type: "uint256", + }, + { + internalType: "uint256", + name: "amount0Min", + type: "uint256", + }, + { + internalType: "uint256", + name: "amount1Min", + type: "uint256", + }, + { + internalType: "uint256", + name: "deadline", + type: "uint256", + }, + ], + internalType: + "struct INonfungiblePositionManager.IncreaseLiquidityParams", + name: "params", + type: "tuple", + }, + ], + name: "increaseLiquidity", + outputs: [ + { + internalType: "uint128", + name: "liquidity", + type: "uint128", + }, + { + internalType: "uint256", + name: "amount0", + type: "uint256", + }, + { + internalType: "uint256", + name: "amount1", + type: "uint256", + }, + ], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "owner", + type: "address", + }, + { + internalType: "address", + name: "operator", + type: "address", + }, + ], + name: "isApprovedForAll", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + components: [ + { + internalType: "address", + name: "token0", + type: "address", + }, + { + internalType: "address", + name: "token1", + type: "address", + }, + { + internalType: "int24", + name: "tickLower", + type: "int24", + }, + { + internalType: "int24", + name: "tickUpper", + type: "int24", + }, + { + internalType: "uint256", + name: "amount0Desired", + type: "uint256", + }, + { + internalType: "uint256", + name: "amount1Desired", + type: "uint256", + }, + { + internalType: "uint256", + name: "amount0Min", + type: "uint256", + }, + { + internalType: "uint256", + name: "amount1Min", + type: "uint256", + }, + { + internalType: "address", + name: "recipient", + type: "address", + }, + { + internalType: "uint256", + name: "deadline", + type: "uint256", + }, + ], + internalType: "struct INonfungiblePositionManager.MintParams", + name: "params", + type: "tuple", + }, + ], + name: "mint", + outputs: [ + { + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + { + internalType: "uint128", + name: "liquidity", + type: "uint128", + }, + { + internalType: "uint256", + name: "amount0", + type: "uint256", + }, + { + internalType: "uint256", + name: "amount1", + type: "uint256", + }, + ], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes[]", + name: "data", + type: "bytes[]", + }, + ], + name: "multicall", + outputs: [ + { + internalType: "bytes[]", + name: "results", + type: "bytes[]", + }, + ], + stateMutability: "payable", + type: "function", + }, + { + inputs: [], + name: "name", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + ], + name: "ownerOf", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "spender", + type: "address", + }, + { + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + { + internalType: "uint256", + name: "deadline", + type: "uint256", + }, + { + internalType: "uint8", + name: "v", + type: "uint8", + }, + { + internalType: "bytes32", + name: "r", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "s", + type: "bytes32", + }, + ], + name: "permit", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [], + name: "poolDeployer", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + ], + name: "positions", + outputs: [ + { + internalType: "uint96", + name: "nonce", + type: "uint96", + }, + { + internalType: "address", + name: "operator", + type: "address", + }, + { + internalType: "address", + name: "token0", + type: "address", + }, + { + internalType: "address", + name: "token1", + type: "address", + }, + { + internalType: "int24", + name: "tickLower", + type: "int24", + }, + { + internalType: "int24", + name: "tickUpper", + type: "int24", + }, + { + internalType: "uint128", + name: "liquidity", + type: "uint128", + }, + { + internalType: "uint256", + name: "feeGrowthInside0LastX128", + type: "uint256", + }, + { + internalType: "uint256", + name: "feeGrowthInside1LastX128", + type: "uint256", + }, + { + internalType: "uint128", + name: "tokensOwed0", + type: "uint128", + }, + { + internalType: "uint128", + name: "tokensOwed1", + type: "uint128", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "refundNativeToken", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "from", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + ], + name: "safeTransferFrom", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "from", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + { + internalType: "bytes", + name: "_data", + type: "bytes", + }, + ], + name: "safeTransferFrom", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + internalType: "uint256", + name: "deadline", + type: "uint256", + }, + { + internalType: "uint8", + name: "v", + type: "uint8", + }, + { + internalType: "bytes32", + name: "r", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "s", + type: "bytes32", + }, + ], + name: "selfPermit", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "uint256", + name: "nonce", + type: "uint256", + }, + { + internalType: "uint256", + name: "expiry", + type: "uint256", + }, + { + internalType: "uint8", + name: "v", + type: "uint8", + }, + { + internalType: "bytes32", + name: "r", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "s", + type: "bytes32", + }, + ], + name: "selfPermitAllowed", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "uint256", + name: "nonce", + type: "uint256", + }, + { + internalType: "uint256", + name: "expiry", + type: "uint256", + }, + { + internalType: "uint8", + name: "v", + type: "uint8", + }, + { + internalType: "bytes32", + name: "r", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "s", + type: "bytes32", + }, + ], + name: "selfPermitAllowedIfNecessary", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + internalType: "uint256", + name: "deadline", + type: "uint256", + }, + { + internalType: "uint8", + name: "v", + type: "uint8", + }, + { + internalType: "bytes32", + name: "r", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "s", + type: "bytes32", + }, + ], + name: "selfPermitIfNecessary", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "operator", + type: "address", + }, + { + internalType: "bool", + name: "approved", + type: "bool", + }, + ], + name: "setApprovalForAll", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes4", + name: "interfaceId", + type: "bytes4", + }, + ], + name: "supportsInterface", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "uint256", + name: "amountMinimum", + type: "uint256", + }, + { + internalType: "address", + name: "recipient", + type: "address", + }, + ], + name: "sweepToken", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [], + name: "symbol", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "index", + type: "uint256", + }, + ], + name: "tokenByIndex", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "owner", + type: "address", + }, + { + internalType: "uint256", + name: "index", + type: "uint256", + }, + ], + name: "tokenOfOwnerByIndex", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + ], + name: "tokenURI", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "totalSupply", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "from", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + ], + name: "transferFrom", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "amountMinimum", + type: "uint256", + }, + { + internalType: "address", + name: "recipient", + type: "address", + }, + ], + name: "unwrapWNativeToken", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + stateMutability: "payable", + type: "receive", + }, +] as const; + +export class PositionManager__factory { + static readonly abi = _abi; + static createInterface(): PositionManagerInterface { + return new Interface(_abi) as PositionManagerInterface; + } + static connect( + address: string, + runner?: ContractRunner | null + ): PositionManager { + return new Contract(address, _abi, runner) as unknown as PositionManager; + } +} diff --git a/packages/adapters-library/src/adapters/quickswap-v3/contracts/factories/index.ts b/packages/adapters-library/src/adapters/quickswap-v3/contracts/factories/index.ts new file mode 100644 index 000000000..609842938 --- /dev/null +++ b/packages/adapters-library/src/adapters/quickswap-v3/contracts/factories/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { PositionManager__factory } from "./PositionManager__factory"; diff --git a/packages/adapters-library/src/adapters/quickswap-v3/contracts/index.ts b/packages/adapters-library/src/adapters/quickswap-v3/contracts/index.ts new file mode 100644 index 000000000..b4cc57de7 --- /dev/null +++ b/packages/adapters-library/src/adapters/quickswap-v3/contracts/index.ts @@ -0,0 +1,6 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { PositionManager } from "./PositionManager"; +export * as factories from "./factories"; +export { PositionManager__factory } from "./factories/PositionManager__factory"; diff --git a/packages/adapters-library/src/adapters/quickswap-v3/products/pool/quickswapV3PoolAdapter.ts b/packages/adapters-library/src/adapters/quickswap-v3/products/pool/quickswapV3PoolAdapter.ts new file mode 100644 index 000000000..75ee0419e --- /dev/null +++ b/packages/adapters-library/src/adapters/quickswap-v3/products/pool/quickswapV3PoolAdapter.ts @@ -0,0 +1,369 @@ +import { getAddress } from 'ethers' +import { AdaptersController } from '../../../../core/adaptersController' +import { Chain } from '../../../../core/constants/chains' +import { NotImplementedError } from '../../../../core/errors/errors' +import { CustomJsonRpcProvider } from '../../../../core/provider/CustomJsonRpcProvider' +import { filterMapAsync } from '../../../../core/utils/filters' +import { getTokenMetadata } from '../../../../core/utils/getTokenMetadata' +import { Helpers } from '../../../../scripts/helpers' +import { + IProtocolAdapter, + ProtocolToken, +} from '../../../../types/IProtocolAdapter' +import { + GetEventsInput, + GetPositionsInput, + GetTotalValueLockedInput, + MovementsByBlock, + PositionType, + ProtocolAdapterParams, + ProtocolDetails, + ProtocolPosition, + ProtocolTokenTvl, + TokenType, + Underlying, + UnwrapExchangeRate, + UnwrapInput, +} from '../../../../types/adapter' +import { Erc20Metadata } from '../../../../types/erc20Metadata' +import { Protocol } from '../../../protocols' +import { PositionManager__factory } from '../../contracts' + +// A deadline value needs to be passed to the call, so a stub is generated here +const deadline = Math.floor(Date.now() - 1000) + 60 * 10 + +const positionManagerCommonAddress = getAddress( + '0x8ef88e4c7cfbbac1c163f7eddd4b578792201de6', +) + +const contractAddresses: Partial> = { + [Chain.Polygon]: { + positionManager: positionManagerCommonAddress, + }, +} + +export const maxUint128 = 2n ** 128n - 1n + +export class QuickswapV3PoolAdapter implements IProtocolAdapter { + adapterSettings = { + enablePositionDetectionByProtocolTokenTransfer: false, + includeInUnwrap: false, + } + + productId = 'pool' + protocolId: Protocol + chainId: Chain + helpers: Helpers + + adaptersController: AdaptersController + + provider: CustomJsonRpcProvider + + constructor({ + provider, + chainId, + protocolId, + adaptersController, + helpers, + }: ProtocolAdapterParams) { + this.provider = provider + this.chainId = chainId + this.protocolId = protocolId + this.adaptersController = adaptersController + this.helpers = helpers + } + + unwrap(_input: UnwrapInput): Promise { + throw new NotImplementedError() + } + + async getTotalValueLocked( + _input: GetTotalValueLockedInput, + ): Promise { + throw new NotImplementedError() + } + + getProtocolDetails(): ProtocolDetails { + return { + protocolId: this.protocolId, + name: 'QuickswapV3', + description: 'Quickswap v3 defi adapter', + siteUrl: 'https://uniswap.org/', + iconUrl: '', + positionType: PositionType.Supply, + chainId: this.chainId, + productId: this.productId, + } + } + + async getProtocolTokens(): Promise { + throw new NotImplementedError() + } + + async getPositions({ + userAddress, + blockNumber, + tokenIds: tokenIdsRaw, + }: GetPositionsInput): Promise { + const positionsManagerContract = PositionManager__factory.connect( + contractAddresses[this.chainId]!.positionManager, + this.provider, + ) + + const tokenIds = + tokenIdsRaw?.map((tokenId) => BigInt(tokenId)) ?? + (await this.getTokenIds(userAddress, blockNumber)) + + return filterMapAsync(tokenIds, async (tokenId) => { + const position = await positionsManagerContract.positions(tokenId, { + blockTag: blockNumber, + }) + + if (position.liquidity === 0n) { + return undefined + } + + const [ + { amount0, amount1 }, + { amount0: amount0Fee, amount1: amount1Fee }, + token0Metadata, + token1Metadata, + ] = await Promise.all([ + positionsManagerContract.decreaseLiquidity.staticCall( + { + tokenId: tokenId, + liquidity: position.liquidity, + amount0Min: 0n, + amount1Min: 0n, + deadline, + }, + { from: userAddress, blockTag: blockNumber }, + ), + positionsManagerContract.collect.staticCall( + { + tokenId, + recipient: userAddress, + amount0Max: maxUint128, + amount1Max: maxUint128, + }, + { from: userAddress, blockTag: blockNumber }, + ), + getTokenMetadata(position.token0, this.chainId, this.provider), + getTokenMetadata(position.token1, this.chainId, this.provider), + ]) + + const nftName = this.protocolTokenName( + token0Metadata.symbol, + token1Metadata.symbol, + ) + + return { + address: contractAddresses[this.chainId]!.positionManager, + tokenId: tokenId.toString(), + name: nftName, + symbol: nftName, + decimals: 18, + balanceRaw: position.liquidity, + type: TokenType.Protocol, + tokens: [ + this.createUnderlyingToken( + position.token0, + token0Metadata, + amount0, + TokenType.Underlying, + ), + this.createUnderlyingToken( + position.token0, + token0Metadata, + amount0Fee, + TokenType.UnderlyingClaimable, + ), + this.createUnderlyingToken( + position.token1, + token1Metadata, + amount1, + TokenType.Underlying, + ), + this.createUnderlyingToken( + position.token1, + token1Metadata, + amount1Fee, + TokenType.UnderlyingClaimable, + ), + ], + } + }) + } + + private async getTokenIds( + userAddress: string, + blockNumber: number | undefined, + ): Promise { + const positionsManagerContract = PositionManager__factory.connect( + contractAddresses[this.chainId]!.positionManager, + this.provider, + ) + const balanceOf = await positionsManagerContract.balanceOf(userAddress, { + blockTag: blockNumber, + }) + + return await Promise.all( + [...Array(Number(balanceOf)).keys()].map(async (index) => { + return positionsManagerContract.tokenOfOwnerByIndex( + userAddress, + index, + { + blockTag: blockNumber, + }, + ) + }), + ) + } + + private protocolTokenName(token0Symbol: string, token1Symbol: string) { + return `${token0Symbol} / ${token1Symbol}` + } + + async getWithdrawals({ + protocolTokenAddress, + fromBlock, + toBlock, + tokenId, + }: GetEventsInput): Promise { + if (!tokenId) { + throw new Error('TokenId required for uniswap withdrawals') + } + + return await this.getUniswapMovements({ + protocolTokenAddress, + fromBlock, + toBlock, + eventType: 'withdrawals', + tokenId, + }) + } + + async getDeposits({ + protocolTokenAddress, + fromBlock, + toBlock, + tokenId, + }: GetEventsInput): Promise { + if (!tokenId) { + throw new Error('TokenId required for uniswap deposits') + } + return await this.getUniswapMovements({ + protocolTokenAddress, + fromBlock, + toBlock, + eventType: 'deposit', + tokenId, + }) + } + + private createUnderlyingToken( + address: string, + metadata: Erc20Metadata, + balanceRaw: bigint, + type: typeof TokenType.Underlying | typeof TokenType.UnderlyingClaimable, + ): Underlying { + return { + address, + name: metadata.name, + symbol: metadata.symbol, + decimals: metadata.decimals, + balanceRaw, + type, + } + } + + private async getUniswapMovements({ + protocolTokenAddress, + eventType, + fromBlock, + toBlock, + tokenId, + }: { + protocolTokenAddress: string + eventType: 'withdrawals' | 'deposit' + fromBlock: number + toBlock: number + tokenId: string + }): Promise { + const positionsManagerContract = PositionManager__factory.connect( + protocolTokenAddress, + this.provider, + ) + + const eventFilters = { + deposit: positionsManagerContract.filters.IncreaseLiquidity(tokenId), + withdrawals: positionsManagerContract.filters.Collect(tokenId), + } + + const { token0, token1 } = await positionsManagerContract + .positions(tokenId, { blockTag: toBlock }) // Encountered failures if nft not yet minted + .catch((error) => { + if (error?.message?.includes('Invalid token ID')) { + throw new Error( + `Uniswap tokenId: ${tokenId} at blocknumber: ${fromBlock} does not exist, has position been minted yet or burned?`, + ) + } + + throw new Error(error) + }) + const [token0Metadata, token1Metadata] = await Promise.all([ + getTokenMetadata(token0, this.chainId, this.provider), + getTokenMetadata(token1, this.chainId, this.provider), + ]) + + const eventResults = await positionsManagerContract.queryFilter( + eventFilters[eventType], + fromBlock, + toBlock, + ) + + return await Promise.all( + eventResults.map(async (transferEvent) => { + const { + blockNumber, + args: { amount0, amount1 }, + transactionHash, + } = transferEvent + + return { + transactionHash, + protocolToken: { + address: protocolTokenAddress, + name: this.protocolTokenName( + token0Metadata.symbol, + token1Metadata.symbol, + ), + symbol: this.protocolTokenName( + token0Metadata.symbol, + token1Metadata.symbol, + ), + decimals: 18, + tokenId, + }, + tokens: [ + { + type: TokenType.Underlying, + balanceRaw: amount0, + ...token0Metadata, + transactionHash, + blockNumber, + }, + { + type: TokenType.Underlying, + balanceRaw: amount1, + ...token1Metadata, + transactionHash, + blockNumber, + }, + ], + blockNumber, + } + }), + ) + } +} diff --git a/packages/adapters-library/src/adapters/quickswap-v3/products/pool/tests/snapshots/matic.positions.1.json b/packages/adapters-library/src/adapters/quickswap-v3/products/pool/tests/snapshots/matic.positions.1.json new file mode 100644 index 000000000..6881d4ba5 --- /dev/null +++ b/packages/adapters-library/src/adapters/quickswap-v3/products/pool/tests/snapshots/matic.positions.1.json @@ -0,0 +1,115 @@ +{ + "blockNumber": 65031322, + "latency": "Latency: 2.306 seconds", + "aggregatedValues": ["USD5.73"], + "snapshot": [ + { + "protocolId": "quickswap-v3", + "name": "QuickswapV3", + "description": "Quickswap v3 defi adapter", + "siteUrl": "https://uniswap.org/", + "iconUrl": "", + "positionType": "supply", + "chainId": 137, + "productId": "pool", + "chainName": "matic", + "success": true, + "tokens": [ + { + "address": "0x8eF88E4c7CfbbaC1C163f7eddd4B578792201de6", + "tokenId": "144215", + "name": "GEMS / USDC", + "symbol": "GEMS / USDC", + "decimals": 18, + "balanceRaw": "3212n", + "type": "protocol", + "tokens": [ + { + "address": "0x25eFae7B0b2866CaFB14E8eaD333a42eeb2A0b80", + "name": "GEMS", + "symbol": "GEMS", + "decimals": 6, + "balanceRaw": "2n", + "type": "underlying", + "balance": 0.000002, + "price": 1144423.0093633893, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/polygon/assets/0x25eFae7B0b2866CaFB14E8eaD333a42eeb2A0b80/logo.png" + }, + { + "address": "0x25eFae7B0b2866CaFB14E8eaD333a42eeb2A0b80", + "name": "GEMS", + "symbol": "GEMS", + "decimals": 6, + "balanceRaw": "0n", + "type": "underlying-claimable", + "balance": 0, + "price": 1144423.0093633893, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/polygon/assets/0x25eFae7B0b2866CaFB14E8eaD333a42eeb2A0b80/logo.png" + }, + { + "address": "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359", + "name": "USD Coin", + "symbol": "USDC", + "decimals": 6, + "balanceRaw": "3440306n", + "type": "underlying", + "balance": 3.440306, + "price": 1.0003426788674818, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/polygon/assets/0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359/logo.png" + }, + { + "address": "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359", + "name": "USD Coin", + "symbol": "USDC", + "decimals": 6, + "balanceRaw": "0n", + "type": "underlying-claimable", + "balance": 0, + "price": 1.0003426788674818, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/polygon/assets/0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359/logo.png" + } + ], + "balance": 3.212e-15 + } + ] + } + ], + "rpcResponses": { + "e0177b5ba064aa61c19a0ab79c2f5808": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000025efae7b0b2866cafb14e8ead333a42eeb2a0b800000000000000000000000003c499c542cef5e3811e1192ce70d8cc03d5c3359fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff2764c00000000000000000000000000000000000000000000000000000000000d89b40000000000000000000000000000000000000000000000000000000000000c8c000000000000000000000000000000000005b6ea650746919b0086c6889e4eac00000000000000000000000000000012369ae9583bff214b3a49aaa6260b1df900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "d46b056e05901c95f53af44265a0c092": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000447454d5300000000000000000000000000000000000000000000000000000000" + }, + "6fe8357c30f76dbce60551e0bc30ef32": { + "result": "0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000045553444300000000000000000000000000000000000000000000000000000000" + }, + "6e0197cbbdb3f4d59424e743e9f94726": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000006" + }, + "1698537ad7769ae9ce61e1fa7ae923a7": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000006" + }, + "4c2395972cf16e9aea457d32ae224db9": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000855534420436f696e000000000000000000000000000000000000000000000000" + }, + "41d815735fd2625d265ec17d75294456": { + "result": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "b1e8b757056982dae9b12b81414dee86": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000447454d5300000000000000000000000000000000000000000000000000000000" + }, + "6a466efce69f37f55f5c16e96368da95": { + "result": "0x00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000347eb2" + }, + "d0763441238c30f980d1abb9a13d42c3": { + "result": "0x000000000000000000000000000000000000000000000003000000000016ade4000000000000000000000000000000000000000000000000000000540b7d168000000000000000000000000000000000000000000000000000000000674ef01600000000000000000000000000000000000000000000000000000000674ef01b000000000000000000000000000000000000000000000003000000000016ade4" + }, + "094ae249554f8da54594523c3d01017f": { + "result": "0x0000000000000000000000000000000000000fa19ed22c324c8ba6d59855959f" + }, + "56bfa0a22ea83d15e0f5bd3be2c87d23": { + "result": "0x000000000000000000000000000000000000000000e53bc4ee03d8c2ea23b506" + } + } +} diff --git a/packages/adapters-library/src/adapters/quickswap-v3/products/pool/tests/snapshots/matic.positions.2.json b/packages/adapters-library/src/adapters/quickswap-v3/products/pool/tests/snapshots/matic.positions.2.json new file mode 100644 index 000000000..ca7646bdc --- /dev/null +++ b/packages/adapters-library/src/adapters/quickswap-v3/products/pool/tests/snapshots/matic.positions.2.json @@ -0,0 +1,201 @@ +{ + "blockNumber": 65031322, + "latency": "Latency: 1.601 seconds", + "aggregatedValues": ["USD6,980.43", "USD2,230.10"], + "snapshot": [ + { + "protocolId": "quickswap-v3", + "name": "QuickswapV3", + "description": "Quickswap v3 defi adapter", + "siteUrl": "https://uniswap.org/", + "iconUrl": "", + "positionType": "supply", + "chainId": 137, + "productId": "pool", + "chainName": "matic", + "success": true, + "tokens": [ + { + "address": "0x8eF88E4c7CfbbaC1C163f7eddd4B578792201de6", + "tokenId": "143872", + "name": "USDC / WETH", + "symbol": "USDC / WETH", + "decimals": 18, + "balanceRaw": "1278534390096729n", + "type": "protocol", + "tokens": [ + { + "address": "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359", + "name": "USD Coin", + "symbol": "USDC", + "decimals": 6, + "balanceRaw": "4220633384n", + "type": "underlying", + "balance": 4220.633384, + "price": 1.0003426788674818, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/polygon/assets/0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359/logo.png" + }, + { + "address": "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359", + "name": "USD Coin", + "symbol": "USDC", + "decimals": 6, + "balanceRaw": "3189059n", + "type": "underlying-claimable", + "balance": 3.189059, + "price": 1.0003426788674818, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/polygon/assets/0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359/logo.png" + }, + { + "address": "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619", + "name": "Wrapped Ether", + "symbol": "WETH", + "decimals": 18, + "balanceRaw": "762303583686887111n", + "type": "underlying", + "balance": 0.7623035836868871, + "price": 3609.7, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/polygon/assets/0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619/logo.png" + }, + { + "address": "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619", + "name": "Wrapped Ether", + "symbol": "WETH", + "decimals": 18, + "balanceRaw": "961159384794215n", + "type": "underlying-claimable", + "balance": 0.000961159384794215, + "price": 3609.7, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/polygon/assets/0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619/logo.png" + } + ], + "balance": 0.001278534390096729 + }, + { + "address": "0x8eF88E4c7CfbbaC1C163f7eddd4B578792201de6", + "tokenId": "144209", + "name": "WBTC / USDC", + "symbol": "WBTC / USDC", + "decimals": 18, + "balanceRaw": "1744419146n", + "type": "protocol", + "tokens": [ + { + "address": "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6", + "name": "(PoS) Wrapped BTC", + "symbol": "WBTC", + "decimals": 8, + "balanceRaw": "995946n", + "type": "underlying", + "balance": 0.00995946, + "price": 94678.12887927523, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/polygon/assets/0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6/logo.png" + }, + { + "address": "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6", + "name": "(PoS) Wrapped BTC", + "symbol": "WBTC", + "decimals": 8, + "balanceRaw": "40n", + "type": "underlying-claimable", + "balance": 4e-7, + "price": 94678.12887927523, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/polygon/assets/0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6/logo.png" + }, + { + "address": "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174", + "name": "USD Coin (PoS)", + "symbol": "USDC", + "decimals": 6, + "balanceRaw": "1287096827n", + "type": "underlying", + "balance": 1287.096827, + "price": 0.9999919297677933, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/polygon/assets/0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174/logo.png" + }, + { + "address": "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174", + "name": "USD Coin (PoS)", + "symbol": "USDC", + "decimals": 6, + "balanceRaw": "34154n", + "type": "underlying-claimable", + "balance": 0.034154, + "price": 0.9999919297677933, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/polygon/assets/0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174/logo.png" + } + ], + "balance": 1.744419146e-9 + } + ] + } + ], + "rpcResponses": { + "2d64f648c71da7691e842dc43e0e28de": { + "result": "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001bfd67037b42cf73acf2047067bd4f2c47d9bfd60000000000000000000000002791bca1f2de4661ed88a30c99a7a9449aa8417400000000000000000000000000000000000000000000000000000000000109c80000000000000000000000000000000000000000000000000000000000010d100000000000000000000000000000000000000000000000000000000067f9b94a00000000000000000000000000000000002456d4d33095937929804bac6ad6fe000000000000000000000000000000036f7752dc70d8405c498d8b52b4194c02000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016c2" + }, + "93359376618ee9f334c8a54be63b20f0": { + "result": "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003c499c542cef5e3811e1192ce70d8cc03d5c33590000000000000000000000007ceb23fd6bc0add59e62ac25578270cff1b9f619000000000000000000000000000000000000000000000000000000000002f490000000000000000000000000000000000000000000000000000000000002fbd400000000000000000000000000000000000000000000000000048ad1fc27a359fffffffffffffffffffffffffffffffffffff30af5446a1ef7db61b677022552fffffffffffffffffffffffffffffed19b32a7d9ed08c87ad03936360f26dc2500000000000000000000000000000000000000000000000000000000003063b6000000000000000000000000000000000000000000000000000367327702198c" + }, + "4c2395972cf16e9aea457d32ae224db9": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000855534420436f696e000000000000000000000000000000000000000000000000" + }, + "1698537ad7769ae9ce61e1fa7ae923a7": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000006" + }, + "893d186d9d05558e733e69e1f37eb7c3": { + "result": "0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000045745544800000000000000000000000000000000000000000000000000000000" + }, + "e4b595824c3a04bb185c028107b16418": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000012" + }, + "14312fc4cc8c7e5b856b2a686d5bbaed": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000001128506f5329205772617070656420425443000000000000000000000000000000" + }, + "6fe8357c30f76dbce60551e0bc30ef32": { + "result": "0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000045553444300000000000000000000000000000000000000000000000000000000" + }, + "8ef1338123cdb0487272e3d828f4f192": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000d5772617070656420457468657200000000000000000000000000000000000000" + }, + "af714d7da522658c60ccd5609254d5a6": { + "result": "0x000000000000000000000000000000000000000000000000000000000030a94300000000000000000000000000000000000000000000000000036a2b5bb40467" + }, + "e63d5569a7ef34a378a0c982f81acd52": { + "result": "0x00000000000000000000000000000000000000000000000000000000fb91c1280000000000000000000000000000000000000000000000000a943f120caa06c7" + }, + "bd42322de94bb4ff22c814c37dd2fccb": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000e55534420436f696e2028506f5329000000000000000000000000000000000000" + }, + "c094ff81c2022934dfe99642fc106327": { + "result": "0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000045742544300000000000000000000000000000000000000000000000000000000" + }, + "1ea4f8f23b28e43986a35eec8622faac": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000008" + }, + "ede4d9b8d019eefcf3458859d401fc11": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000006" + }, + "d7cb286f9d9ce2253b11434cdd05781b": { + "result": "0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000045553444300000000000000000000000000000000000000000000000000000000" + }, + "22b746facc111404b1e029cbc5633333": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000028000000000000000000000000000000000000000000000000000000000000856a" + }, + "c16c63700d98cffaf183abb6c10d3213": { + "result": "0x00000000000000000000000000000000000000000000000000000000000f326a000000000000000000000000000000000000000000000000000000004cb789fb" + }, + "d0763441238c30f980d1abb9a13d42c3": { + "result": "0x000000000000000000000000000000000000000000000003000000000016ade4000000000000000000000000000000000000000000000000000000540b7d168000000000000000000000000000000000000000000000000000000000674ef01600000000000000000000000000000000000000000000000000000000674ef01b000000000000000000000000000000000000000000000003000000000016ade4" + }, + "56bfa0a22ea83d15e0f5bd3be2c87d23": { + "result": "0x000000000000000000000000000000000000000000e53bc4ee03d8c2ea23b506" + }, + "2e72889f506c96d1468fda1b8fe7b38c": { + "result": "0x000000000000000000000000000000000000000000e527316a52f5cf483ce62b" + }, + "05caeaa49c83702e4164f4ccb108bedd": { + "result": "0x00000000000000000000000000000000000000034f7f9dbc04cb35a0c5bac871" + } + } +} diff --git a/packages/adapters-library/src/adapters/quickswap-v3/products/pool/tests/snapshots/matic.positions.json b/packages/adapters-library/src/adapters/quickswap-v3/products/pool/tests/snapshots/matic.positions.json new file mode 100644 index 000000000..b3426b2f6 --- /dev/null +++ b/packages/adapters-library/src/adapters/quickswap-v3/products/pool/tests/snapshots/matic.positions.json @@ -0,0 +1,1269 @@ +{ + "blockNumber": 65031322, + "latency": "Latency: 1.468 seconds", + "aggregatedValues": ["USD5.73"], + "snapshot": [ + { + "protocolId": "quickswap-v3", + "name": "UniswapV3", + "description": "UniswapV3 defi adapter", + "siteUrl": "https://uniswap.org/", + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/ethereum/assets/0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984/logo.png", + "positionType": "supply", + "chainId": 137, + "productId": "pool", + "chainName": "matic", + "success": true, + "tokens": [ + { + "address": "0x8eF88E4c7CfbbaC1C163f7eddd4B578792201de6", + "tokenId": "144215", + "name": "GEMS / USDC - 3.3333%", + "symbol": "GEMS / USDC - 3.3333%", + "decimals": 18, + "balanceRaw": "3212n", + "type": "protocol", + "tokens": [ + { + "address": "0x25eFae7B0b2866CaFB14E8eaD333a42eeb2A0b80", + "name": "GEMS", + "symbol": "GEMS", + "decimals": 6, + "balanceRaw": "2n", + "type": "underlying", + "balance": 0.000002, + "price": 1144423.0093633893, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/polygon/assets/0x25eFae7B0b2866CaFB14E8eaD333a42eeb2A0b80/logo.png" + }, + { + "address": "0x25eFae7B0b2866CaFB14E8eaD333a42eeb2A0b80", + "name": "GEMS", + "symbol": "GEMS", + "decimals": 6, + "balanceRaw": "0n", + "type": "underlying-claimable", + "balance": 0, + "price": 1144423.0093633893, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/polygon/assets/0x25eFae7B0b2866CaFB14E8eaD333a42eeb2A0b80/logo.png" + }, + { + "address": "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359", + "name": "USD Coin", + "symbol": "USDC", + "decimals": 6, + "balanceRaw": "3440306n", + "type": "underlying", + "balance": 3.440306, + "price": 1.0003426788674818, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/polygon/assets/0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359/logo.png" + }, + { + "address": "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359", + "name": "USD Coin", + "symbol": "USDC", + "decimals": 6, + "balanceRaw": "0n", + "type": "underlying-claimable", + "balance": 0, + "price": 1.0003426788674818, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/polygon/assets/0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359/logo.png" + } + ], + "balance": 3.212e-15 + } + ] + } + ], + "rpcResponses": { + "a3063c1c14a459834662cd9b3043f110": { + "result": [ + { + "address": "0x7ceb23fd6bc0add59e62ac25578270cff1b9f619", + "blockHash": "0xf11aaf4f65fa734c8bc689723dcbc394fce7a20a02cc06f6535bbba7ab3b5dcf", + "blockNumber": "0x1120880", + "data": "0x0000000000000000000000000000000000000000000000000372378b17ea2000", + "logIndex": "0x296", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xc4105168125ec4eabe01ed28a091223c01122575f8ecb27ee8d1f1c237470c48", + "transactionIndex": "0x76" + }, + { + "address": "0x7ceb23fd6bc0add59e62ac25578270cff1b9f619", + "blockHash": "0x69d967bda8738fda5e0d95ec27c9befa5dccef9b9f11644a0d6913dfeaea21a4", + "blockNumber": "0x1131d80", + "data": "0x00000000000000000000000000000000000000000000000002f77622734852b0", + "logIndex": "0x249", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xea8a6009e9a7f81ac4857b0d604d69a00590019b8a309408b5d5d1cd440133ae", + "transactionIndex": "0x69" + }, + { + "address": "0x66ff795535cf162d29f6b15ed546a3e148eff0fb", + "blockHash": "0x229d5aac9ec74c6083dec93db2d82ca92f994dcd11cc4d0b1a98140745a02665", + "blockNumber": "0x113252f", + "data": "0x00000000000000000000000000000000000000000000000286abb65f1dc6ad63", + "logIndex": "0xc5", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x3e8b5463afbc08e20af3e03048f49814ac0642413e066218df8fd6adebd39bea", + "transactionIndex": "0x18" + }, + { + "address": "0x7ceb23fd6bc0add59e62ac25578270cff1b9f619", + "blockHash": "0x23f2c73925ba846c6c2937dd04fd382e1040b3fcb3071b9085aee438420d52fe", + "blockNumber": "0x1133200", + "data": "0x00000000000000000000000000000000000000000000000003782dace9d90000", + "logIndex": "0x8", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xa0f08289d3e2a2664069d8b5dfbd9747bc6953bc51fc6cf1df64d2a0e9314538", + "transactionIndex": "0x0" + }, + { + "address": "0x66ff795535cf162d29f6b15ed546a3e148eff0fb", + "blockHash": "0x780eb22cf1ba32d8fa78edfdbd9dcc1ea78c431f5143b9370923d84224a6ad5c", + "blockNumber": "0x11363b2", + "data": "0x000000000000000000000000000000000000000000000003433bc9f7e08e0c20", + "logIndex": "0x11e", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x1583940483160749c7e045b737a579aa64bf61d3da2f0a844d53248eb8d42727", + "transactionIndex": "0x23" + }, + { + "address": "0x87d68f797623590e45982ad0f21228557207fdda", + "blockHash": "0x12c4d66bc0d006b35321a1deb3229a7a408d3fcebd3ed78725d35a7c7cdd5aa8", + "blockNumber": "0x113ad7e", + "data": "0x000000000000000000000000000000000000000000000000003dea26df6ef5e7", + "logIndex": "0xe3", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x4746e967933bccaa037269dc045b820670bc0d771ade90efe27f7b81c02042cd", + "transactionIndex": "0x22" + }, + { + "address": "0xf28164a485b0b2c90639e47b0f377b4a438a16b1", + "blockHash": "0xc36030dcf4de219a298e32e395f6af9966381a4f28403da9a51891d6de75c51b", + "blockNumber": "0x113b556", + "data": "0x0000000000000000000000000000000000000000000000001783444676414c61", + "logIndex": "0x22c", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xa6f8c47a91dda97530eb3194ae203c729c2151b823bfe9b3925f0fde2c7e2026", + "transactionIndex": "0x35" + }, + { + "address": "0x37e6449b0e99befd2a708ea048d970f4ff4dc65d", + "blockHash": "0x36e780c932eb88e2b6bfe0628a49a6b9d3da4c631028a96c5c05b42ebe77b084", + "blockNumber": "0x114b894", + "data": "0x00000000000000000000000000000000000000000000002f7412f4aef094376a", + "logIndex": "0x145", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x249a533389d3321df8624505ff2bc8517cbab442e21f1a7de7ba403f33a96335", + "transactionIndex": "0x26" + }, + { + "address": "0xa1c57f48f0deb89f569dfbe6e2b7f46d33606fd4", + "blockHash": "0xa2e466c394853dc466bb8f9c36ef875a24d9a7c2746617e57697b3c906a31c54", + "blockNumber": "0x115e400", + "data": "0x0000000000000000000000000000000000000000000001b1b29fb79f0b393c00", + "logIndex": "0x19d", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x2fddda6eae033c3bfb10f72902a339c7db989c148a7728d83d5d610cf42d3ac4", + "transactionIndex": "0xa5" + }, + { + "address": "0x7ceb23fd6bc0add59e62ac25578270cff1b9f619", + "blockHash": "0xa15f9eb1a2bb4e681919d3af8317a04574670acb1492bc19a503f3d4847bc120", + "blockNumber": "0x115e700", + "data": "0x0000000000000000000000000000000000000000000000001bc16d674ec80000", + "logIndex": "0x23b", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x8d02e4d732ac8c0e7c816c9ab9752121540943c6a82b01639e5498efdc51d132", + "transactionIndex": "0x61" + }, + { + "address": "0xc48ae82ca34c63887b975f20aba91a38f2a900b8", + "blockHash": "0x36e54695cac173ad2b69d8c4f8fc6a051e2518eb04130c292f380a29d436be3d", + "blockNumber": "0x115e8eb", + "data": "0x0000000000000000000000000000000000000000000000065794f9a4bc6d9d0f", + "logIndex": "0x168", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x4694324557afed74f2b21372ec7b36b43a7f41b2437c0866876e87518115d302", + "transactionIndex": "0x50" + }, + { + "address": "0xf28164a485b0b2c90639e47b0f377b4a438a16b1", + "blockHash": "0x7229795aef82c3656e3b401fe568fdd40a9b5a2f74e69619ce226e63f125a030", + "blockNumber": "0x11795a5", + "data": "0x0000000000000000000000000000000000000000000000000b7f417a2d34deed", + "logIndex": "0x38a", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xd5c91d81a6fff421998590f3e08a9633c5c036ec29bbbb421602a22fd22737bd", + "transactionIndex": "0x58" + }, + { + "address": "0xf28164a485b0b2c90639e47b0f377b4a438a16b1", + "blockHash": "0x4a44de27cdc2e6421c1213efb79c255c6f9da61e79d4080ea4b6f317ea07204c", + "blockNumber": "0x117988d", + "data": "0x0000000000000000000000000000000000000000000000000555e56d92608fb7", + "logIndex": "0xc8", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xd159c6cc42e931d03a5860990da290714942e09fe94890b6d1b472c972c6ed44", + "transactionIndex": "0x20" + }, + { + "address": "0x1274de0de2e9d9b1d0e06313c0e5edd01cc335ef", + "blockHash": "0xb36925d52f7152f362015904f42c9d5925b41e264066cbafd295135df8cd399e", + "blockNumber": "0x1188dd0", + "data": "0x00000000000000000000000000000000000000000000000062a296ad045d0fc9", + "logIndex": "0x20f", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x95ca001f6e5303c37b908149968900583333c9614bd8c2bb3f5706a589ac1fae", + "transactionIndex": "0x92" + }, + { + "address": "0x37e6449b0e99befd2a708ea048d970f4ff4dc65d", + "blockHash": "0x2010c3861284bac6980addd247839eb8db0d3980d86aceb071f9e6613928c45a", + "blockNumber": "0x1188f5f", + "data": "0x000000000000000000000000000000000000000000000040b602de0768a5760e", + "logIndex": "0x1e8", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x9414feb0dc0ecb0cb82698f757dbcccba762dbd32c99fa95a443b83bb2094176", + "transactionIndex": "0x48" + }, + { + "address": "0xf28164a485b0b2c90639e47b0f377b4a438a16b1", + "blockHash": "0x7f05df820b45fd5f96638cde7f3959c4a687aa243c05f4591920f39dfc5e8dcf", + "blockNumber": "0x119de71", + "data": "0x00000000000000000000000000000000000000000000000005d6fef966d934cb", + "logIndex": "0xf3", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xa8bee3fe3a20487667fba7eb880b2843a7a1135b8111cacdefbb7c4d4c02adff", + "transactionIndex": "0x2d" + }, + { + "address": "0x29429e4099ed88884729b8fa800b9c65dbe57b63", + "blockHash": "0x46948b0487cb603ca45eb2fec4b10d6852845efe9dcaf0a0d97ba278c8e95041", + "blockNumber": "0x11c6886", + "data": "0x000000000000000000000000000000000000000000000000e6b7c2e237151af4", + "logIndex": "0x1c2", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xb799a8d6a6cff639ccf504d1add32f03d4effd57b8117fa058d1cdfdb220ad6c", + "transactionIndex": "0x118" + }, + { + "address": "0x29429e4099ed88884729b8fa800b9c65dbe57b63", + "blockHash": "0xaab3344982da2afaeb1b54bc67aef7d6ee541a3c9ae5bcf3106d8895d7f3d65f", + "blockNumber": "0x11c6b6b", + "data": "0x000000000000000000000000000000000000000000000004ba40e3634810868c", + "logIndex": "0x137", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xe4aadbaa44b5d203ae1f30a57f79bb2034a5e44a04c7873ece849f09a972caff", + "transactionIndex": "0x3b" + }, + { + "address": "0x15551bedc20b01b473da93e6cfa29b1eb7baeabb", + "blockHash": "0xbab591849920a626e132254e7105f517c6423dd9f2655cc147dda38c7d4650f3", + "blockNumber": "0x11c6f99", + "data": "0x000000000000000000000000000000000000000000000005d055c4fe4843afcb", + "logIndex": "0x1be", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xa27f637644c6e1676a3c8633f8ce5332d07ea19a557f01266533f6cd3f3d554b", + "transactionIndex": "0x152" + }, + { + "address": "0xf69e93771f11aecd8e554aa165c3fe7fd811530c", + "blockHash": "0x3a9b0d122159ae86da52ff08ee06739706e6927fd856a99544bb90275f368d04", + "blockNumber": "0x11c89a0", + "data": "0x00000000000000000000000000000000000000000000000337bac7e545e084d1", + "logIndex": "0x1ac", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x35721d9e1c51a9c6d9acc02ca3277c8f656a3bfab1268a78928cc901a4e9285b", + "transactionIndex": "0x38" + }, + { + "address": "0xf69e93771f11aecd8e554aa165c3fe7fd811530c", + "blockHash": "0x5fa5de791bcd52d1fbb48754cf8f430c2d843d0f831305da3e5703f0659eda2e", + "blockNumber": "0x11c8aa2", + "data": "0x00000000000000000000000000000000000000000000000fde8547a3b8c52f85", + "logIndex": "0xdb", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x83b57f2426ff62765b83e7b833adbb5953e3512fcf4067e465a2cf5fc9859a0c", + "transactionIndex": "0x1d" + }, + { + "address": "0xf28164a485b0b2c90639e47b0f377b4a438a16b1", + "blockHash": "0x91795694eea43ebc941d654f7defbce427bd56684fcd9621207ee170283b89b2", + "blockNumber": "0x11df444", + "data": "0x0000000000000000000000000000000000000000000000000b11ab566a8d393a", + "logIndex": "0x12e", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xb38169de208df95f246f4a8b46e61cd927d6fa6e1ab94afe9fc8e8b37ace6385", + "transactionIndex": "0x2b" + }, + { + "address": "0xf28164a485b0b2c90639e47b0f377b4a438a16b1", + "blockHash": "0xc5cf27f4674cef2de3c0d69d9c65d9a84ee522817f671604b1d1f64505776c4a", + "blockNumber": "0x11eadb1", + "data": "0x00000000000000000000000000000000000000000000000090463c2007d54d43", + "logIndex": "0x2de", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x34a548a5ac3f5f0b6f99dae60ce7211ac79b50b39fafa3d6dc3140f7b836ddcc", + "transactionIndex": "0x139" + }, + { + "address": "0x6928f1577b3507de99490ca8c5acea6fc1d24a84", + "blockHash": "0x4780ddabc57d59eb3008d1ed26be2e0e698ba5665ae535db19944c6283888c30", + "blockNumber": "0x11fc338", + "data": "0x0000000000000000000000000000000000000000000000007b487c89ea6695c3", + "logIndex": "0x13c", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xa11a92a457c127174919d78bb27bb27f5578f671abe237610ee60d2a466f856b", + "transactionIndex": "0x7c" + }, + { + "address": "0x6928f1577b3507de99490ca8c5acea6fc1d24a84", + "blockHash": "0xd025e3233a5eeba16acd8b6b5a9c9dd088e62db8a0438c9969fc802761887396", + "blockNumber": "0x11fc4cc", + "data": "0x0000000000000000000000000000000000000000000000092952168d53799973", + "logIndex": "0x11e", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x08a0b6fa731a434b5f2b5d0d4776647a0ee62f4558ccfc41fa1741204e2b28b6", + "transactionIndex": "0x2b" + }, + { + "address": "0x5cb85aa163b1b443f88a1f9124153e70f6586400", + "blockHash": "0x4c3dc71fc2a484777387c0c5ea761576c21640ab04497711757aff974642d90f", + "blockNumber": "0x11fc6be", + "data": "0x0000000000000000000000000000000000000000000000000001999f78e7116c", + "logIndex": "0x18b", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x6b5d8bf1ff62f21bc4cc9ad879a85000880b09419873985539d5d9313ea6fb29", + "transactionIndex": "0x80" + }, + { + "address": "0x898386dd8756779a4ba4f1462891b92dd76b78ef", + "blockHash": "0x7a0d238732116266a049d8fd5ac43844fa9661af1727d476ba07c3df030a49f8", + "blockNumber": "0x1203434", + "data": "0x00000000000000000000000000000000000000000000000f43d41213b93b3249", + "logIndex": "0x157", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xba4856e4e8b1767954eaad35b5b9d9fba27fe6ce4a2809e94c21480e71d3a5f8", + "transactionIndex": "0xc5" + }, + { + "address": "0xf28164a485b0b2c90639e47b0f377b4a438a16b1", + "blockHash": "0x8dee772ce88b81546ee1cb4d3324e1544971eb4aefe7fc0e911b3d003881b0e0", + "blockNumber": "0x124d2ee", + "data": "0x0000000000000000000000000000000000000000000000000b5344315b8284cd", + "logIndex": "0x328", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x6e5eff57466b2d7b4855d769c25815b48102ea54325508a24a027b9bf2db9d54", + "transactionIndex": "0x36" + }, + { + "address": "0xf28164a485b0b2c90639e47b0f377b4a438a16b1", + "blockHash": "0x4a7e1eec8ad3be9bb0dc390a65f992297cf137c2871a670f339582d6ca8088e2", + "blockNumber": "0x12791e3", + "data": "0x0000000000000000000000000000000000000000000000000ca10a30e2d657c3", + "logIndex": "0x91", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x6efc66f97759925f275035beed2ce86e02bfa20a9ec5cbedf6eb68b520bc8219", + "transactionIndex": "0xc" + }, + { + "address": "0xf28164a485b0b2c90639e47b0f377b4a438a16b1", + "blockHash": "0x6012718d38696ea2f9bed6edfc58164ef921437ecb407eedd2566c5578dcc994", + "blockNumber": "0x12ed313", + "data": "0x0000000000000000000000000000000000000000000000000d3c94f3dae53822", + "logIndex": "0xa6", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xcd71d3a6be0a1b54591b69ff6012180af9d0d7d30b0c176bb8b6af3fc6270197", + "transactionIndex": "0x1e" + }, + { + "address": "0x87d68f797623590e45982ad0f21228557207fdda", + "blockHash": "0xb017d8233ada2960b84c410662447f92383b64b8c274f36a9fb5522e7dec785e", + "blockNumber": "0x1300e9e", + "data": "0x000000000000000000000000000000000000000000000000003dea26de624e94", + "logIndex": "0x15e", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x41de5c2705ebd3624030413b8d2e82b810d472a8d875c98a9875abc8e2839b85", + "transactionIndex": "0x32" + }, + { + "address": "0x898386dd8756779a4ba4f1462891b92dd76b78ef", + "blockHash": "0xc181495ae6ede96a19ab73f5b71daf7dcaa60b4b3038b8f7e7646056ce03ef62", + "blockNumber": "0x1300eb2", + "data": "0x00000000000000000000000000000000000000000000000ef2f1b68dce2137a9", + "logIndex": "0x157", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x4aa5b72d5173ac7728fb390433df61bf69b32ad842ccaf81b0c211185b3e4bbf", + "transactionIndex": "0x50" + }, + { + "address": "0x66ff795535cf162d29f6b15ed546a3e148eff0fb", + "blockHash": "0x6fff128e6a9bf3210631fcc503cba8788e219b4ec45b7def7cf31f290ad3b877", + "blockNumber": "0x1300ecf", + "data": "0x000000000000000000000000000000000000000000000005c9e780bb96e5ec22", + "logIndex": "0xfc", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x4f136ea9462f848f7018aa650a41bc00f85065d46675a2886344cc43f442d9ec", + "transactionIndex": "0x39" + }, + { + "address": "0x1c75bd54ad15449d12e6c24a9b5e8ce1a62c567c", + "blockHash": "0xe9064106773e4862c54e0878aa7aae44694b1ec4f86cd6d66a66c917ec48cf48", + "blockNumber": "0x130105f", + "data": "0x0000000000000000000000000000000000000000000000035eb7b754b698fa96", + "logIndex": "0xdd", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x600d7e94ae1498a88966e2082e14a65701d6e376b688945964fe90f044f90a60", + "transactionIndex": "0x2f" + }, + { + "address": "0x23e93ce78d7fb5287e4b6a8d91403bc5e7ac845a", + "blockHash": "0x5f8bc846833775a07eaf2b6c3a2f87ee40561c57f161977a90508a8be3bb1364", + "blockNumber": "0x13010c5", + "data": "0x000000000000000000000000000000000000000000000007953a53cc60b507ee", + "logIndex": "0x255", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xa451a2e4d15acd47b405882d05df13d1fa7057d368c8b2a485995b115ead00ec", + "transactionIndex": "0x9e" + }, + { + "address": "0x976b7b7fe4293111cacd946c422a64f24a223564", + "blockHash": "0x76acd84a89b06561266df871a99dfc4d1878ff0b989e13041061cfd4ae7332f9", + "blockNumber": "0x130111b", + "data": "0x0000000000000000000000000000000000000000000000008f1d4c2f7eca300f", + "logIndex": "0x8f", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xbe0dc8314e44a2bfb08b146a479dfce5fce360c5b42627ef4963ec465ce1a5e5", + "transactionIndex": "0x13" + }, + { + "address": "0x8167d3156fccdbaf3e43ae019a0e842e5d1f1ac1", + "blockHash": "0xbfe48e5ee72b1401f348244806841a9ec17d67c37c0f213d4d5aa541ea67e028", + "blockNumber": "0x1301388", + "data": "0x0000000000000000000000000000000000000000000000013e0ed088a80c8f43", + "logIndex": "0x18f", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xa1ba266a53be2e542f8cc3edd31bd49658cee7b4648b5e29173cc4edd1928c69", + "transactionIndex": "0xae" + }, + { + "address": "0xbf453e64ee7f43513afdc801f6c0fab250fbcf09", + "blockHash": "0x5b3b5120cfac96c5296c16d83579d061af9d9b729b4a88b4570a6ac979327bd6", + "blockNumber": "0x1301447", + "data": "0x00000000000000000000000000000000000000000000000000004722621a5cc9", + "logIndex": "0xb4", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xffdf74d23a4faa4f53bdaebccf0b2d98e0bdc81b1074370f3cd739f8a4ec8fba", + "transactionIndex": "0x26" + }, + { + "address": "0xf28164a485b0b2c90639e47b0f377b4a438a16b1", + "blockHash": "0x02cc0c815a95eaee89fa061b486946b18ffd7c0f72993c0c2fcd13bd9fb2210d", + "blockNumber": "0x132eaeb", + "data": "0x0000000000000000000000000000000000000000000000000069bf67cadd1e01", + "logIndex": "0x167", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x4384970a9b0c11d1a26b98d552563e2c4631bb04382a02589c3e7edb9bf21b88", + "transactionIndex": "0x1d" + }, + { + "address": "0x019ba0325f1988213d448b3472fa1cf8d07618d7", + "blockHash": "0xea3946b5a0a007350a9c1c0fedbe3e814f08550edee202bfe0c79d9e3911cb9d", + "blockNumber": "0x1336f1e", + "data": "0x0000000000000000000000000000000000000000000000004a4b9d097429feb1", + "logIndex": "0x1cf", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xc80cc01d88af89cb8d7739281647a0d66511c92a3da580679bf451fb97165587", + "transactionIndex": "0x54" + }, + { + "address": "0xf28164a485b0b2c90639e47b0f377b4a438a16b1", + "blockHash": "0x7330ec5bdcc30517ef436a41a48cf3e89f87a6e17323f464ba5e7c0d292dc530", + "blockNumber": "0x135c455", + "data": "0x00000000000000000000000000000000000000000000000002eb886870e91224", + "logIndex": "0x15c", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x89e18d37326129e1be815ec14ba5115cc4954d1cf9d520e67e1b0a6277f78602", + "transactionIndex": "0x2d" + }, + { + "address": "0xf28164a485b0b2c90639e47b0f377b4a438a16b1", + "blockHash": "0x343439fb6ed4dc3d3d35cc38e11831f15b82b8af956b634aaca74d4279839ce7", + "blockNumber": "0x13b3b6c", + "data": "0x00000000000000000000000000000000000000000000000025cd14137353bbb4", + "logIndex": "0x122", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x8ab36f82eb2e0a7c8d84a247e47c02a54eeaadf2bb6b4438d26bcbe33fee04bd", + "transactionIndex": "0x35" + }, + { + "address": "0x66ff795535cf162d29f6b15ed546a3e148eff0fb", + "blockHash": "0xdb360f76e92ea2264f18db18738b67f5e99eadf627f3f1686019851ee3790214", + "blockNumber": "0x13b3da3", + "data": "0x00000000000000000000000000000000000000000000002d9ab1d4cfdc17959d", + "logIndex": "0x295", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x5246a76f0838d00ae620b2f6c242600ea330d9bf91a2a757d11db1262519348e", + "transactionIndex": "0x4a" + }, + { + "address": "0xf28164a485b0b2c90639e47b0f377b4a438a16b1", + "blockHash": "0x8be0764f968170b7622b903fe819453c4a1ce246fe2b12392ef468bdaf0dc27c", + "blockNumber": "0x13b4007", + "data": "0x000000000000000000000000000000000000000000000000c05ffd91bea183d6", + "logIndex": "0x141", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x95d4c1109e89e2cf443b25014bb8756971e7c5c5318495bb282ad6bc0d9914e5", + "transactionIndex": "0x29" + }, + { + "address": "0xf28164a485b0b2c90639e47b0f377b4a438a16b1", + "blockHash": "0x62bf06d6995bca17ef8bcecf7b48ebb5c059d32be7fcfda0c0cfb6bbacd0df18", + "blockNumber": "0x13ec45a", + "data": "0x0000000000000000000000000000000000000000000000000343079a5dd9d184", + "logIndex": "0xa2", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xd1f4fccb14f1a197fe52e22fd1b896229b024432cde69a6a08974b4a19262c43", + "transactionIndex": "0x24" + }, + { + "address": "0x7b2a989c4d1ad1b79a84ce2eb79da5d8d9c2b7a7", + "blockHash": "0x16c562afa93eebaaf2a8ea80da7ae582ba8089219b26cb89553a7c84f7df6b77", + "blockNumber": "0x144e3dc", + "data": "0x", + "logIndex": "0xe5", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692", + "0x0000000000000000000000000000000000000000000000000000000000021261" + ], + "transactionHash": "0xbf6a4fc01295810f2683b6bcc763e9567dce5a2023429b77513095f6f0de72b1", + "transactionIndex": "0x28" + }, + { + "address": "0xf28164a485b0b2c90639e47b0f377b4a438a16b1", + "blockHash": "0x62209f932308e2b049818c3a7b5109b5a245750d6948908b38da5e6fbf80c266", + "blockNumber": "0x1483d99", + "data": "0x000000000000000000000000000000000000000000000000053fae504b6e81a6", + "logIndex": "0x228", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xc0522e3736cd1f0e804084bfaddd69afc4621032153729d4b561d0eb8cd335c3", + "transactionIndex": "0x50" + }, + { + "address": "0xd7f1d4f5a1b44d827a7c3cc5dd46a80fade55558", + "blockHash": "0xd48350e065434ae197ed0e87a20bdae0a144bb2f18b5d8243fabcc9bcf59f0de", + "blockNumber": "0x1491a9e", + "data": "0x000000000000000000000000000000000000000000000263de974ae939fc0000", + "logIndex": "0x70", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x5588bd7ab1b4ec0ca8e251b35ec7d3d82481f3889fa19fda8167876624aa5680", + "transactionIndex": "0x12" + }, + { + "address": "0xd7f1d4f5a1b44d827a7c3cc5dd46a80fade55558", + "blockHash": "0xddd3e72021bbad4cab45ab35b4cf112c86467b59159bc770c5a32da2704486f9", + "blockNumber": "0x14a7801", + "data": "0x000000000000000000000000000000000000000000000263de974ae939fc0000", + "logIndex": "0x49", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x2330c1eecb0bb9bdf0a6ba39398fd47a465b59a7ff8783414cc4874e40b8ed82", + "transactionIndex": "0x5" + }, + { + "address": "0xf28164a485b0b2c90639e47b0f377b4a438a16b1", + "blockHash": "0xcfdbbabe0bd02cfc852e7e1757770d2364b76647d047d3872a8d8e8f663837ec", + "blockNumber": "0x14c1e9c", + "data": "0x000000000000000000000000000000000000000000000000c48a44bdfad6ef6e", + "logIndex": "0x2cf", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x164dd2d9e9c681bc17b64e60fdc2e6e612754e9144de8c15089116335496536b", + "transactionIndex": "0xf1" + }, + { + "address": "0x369582d2010b6ed950b571f4101e3bb9b554876f", + "blockHash": "0x348ab85dfdde63ae609a5b316c11e3730e1e0339ce44220e9b9ce5cc2da98ed6", + "blockNumber": "0x166252a", + "data": "0x00000000000000000000000000000000000000000000003b11b148c10fce0830", + "logIndex": "0x9b", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x648ac05a324d70cfe83f74cd9dca62f8fd5bc08a6163d12679b4d789cde032dc", + "transactionIndex": "0x28" + }, + { + "address": "0x14f2c84a58e065c846c5fdddade0d3548f97a517", + "blockHash": "0x9222fd5d583f1f322dfd96c1f65b19d0651995e03a80e44dfb36ecbe7628e844", + "blockNumber": "0x177cec2", + "data": "0x00000000000000000000000000000000000000000000013a6b2b564871a00000", + "logIndex": "0x3fa", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xfbea3218e921b6ba4807f2e25cf3e1e7a9c4c7eb1bd300f0a0da4ea58c0e115f", + "transactionIndex": "0x28" + }, + { + "address": "0x14f2c84a58e065c846c5fdddade0d3548f97a517", + "blockHash": "0x45e788f5935b040e184de7508033c51dba70fce59b9eafabcd706b2034662c93", + "blockNumber": "0x1785b3c", + "data": "0x00000000000000000000000000000000000000000000013a6b2b564871a00000", + "logIndex": "0x2c4", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x8d2c92554a2c439f16e3f33ab81f0e3a7dd45b9ca14229e63f58294ed19d75a0", + "transactionIndex": "0xd" + }, + { + "address": "0x14f2c84a58e065c846c5fdddade0d3548f97a517", + "blockHash": "0xc38df91e0c1264a628f01ef362b43eb6f8e245571bcb75780faecfe1e0d149bf", + "blockNumber": "0x178e494", + "data": "0x00000000000000000000000000000000000000000000013a6b2b564871a00000", + "logIndex": "0x46e", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x34fd964d801b916ed3b0fe17c6eacaa0a19576db783ff578e598780662c42dc5", + "transactionIndex": "0xc4" + }, + { + "address": "0x14f2c84a58e065c846c5fdddade0d3548f97a517", + "blockHash": "0x728a07b6d17d069ad32f79e1fea716e3c3ea58161f54f45bc313f8ae985fa2de", + "blockNumber": "0x178ed9a", + "data": "0x00000000000000000000000000000000000000000000013a6b2b564871a00000", + "logIndex": "0x48d", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x01f818a8ac98d03f13dbafb02bfc02da99bb5d1895681a5648abd99b3a613d3e", + "transactionIndex": "0x3a" + }, + { + "address": "0x3c03b5b3d21e56611653c2d323c1c3b1207a5f34", + "blockHash": "0x23038c80da25659944a3ab62ada4fba05e8fbbcca99b36987fca0d9aaa138cd7", + "blockNumber": "0x17ca4d0", + "data": "0x", + "logIndex": "0x20", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692", + "0x00000000000000000000000000000000000000000000000000000000000024e8" + ], + "transactionHash": "0xf52952b7d1efdcac429e3c1ce388272ea22393cba5c6296eb2be71cda1307102", + "transactionIndex": "0x8" + }, + { + "address": "0x369582d2010b6ed950b571f4101e3bb9b554876f", + "blockHash": "0x034bf5ef43eab91ce09be464b169b229d0457b955b208a3ed5477df10c6e2bdc", + "blockNumber": "0x19bdc9d", + "data": "0x00000000000000000000000000000000000000000000000750052b85e62bd6b3", + "logIndex": "0xcc", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x25e9795ffc55e8c91953d18b0d30ccccdd276fa7030aa1056dd35bd4ecbb67b6", + "transactionIndex": "0x31" + }, + { + "address": "0x65752c54d9102bdfd69d351e1838a1be83c924c6", + "blockHash": "0x0990d953bef05a228f91478ec9be7057dbf2304820287ceab494778d2ab4556a", + "blockNumber": "0x2163e94", + "data": "0x00000000000000000000000000000000000000000000002082b4826ac35ad8a6", + "logIndex": "0x84", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xb58a4961617fc5dc139926472617dd1c9b072615f20ee7f487a9e44a912086b3", + "transactionIndex": "0x26" + }, + { + "address": "0xe82576bae8c066c3f79c62c98d6e8515762ac4d4", + "blockHash": "0xc28e691cd97142dd0b313c1e0d1ea66d0de3d8957c6931ba189c1d16823d1c72", + "blockNumber": "0x2a4bba9", + "data": "0x", + "logIndex": "0x19c", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692", + "0x0000000000000000000000000000000000000000000000000000000000000141" + ], + "transactionHash": "0xa926540116aa6144942213027c1c2ad9418c24280851639d1ef13cc7ec3f656e", + "transactionIndex": "0x17" + }, + { + "address": "0x958d208cdf087843e9ad98d23823d32e17d723a1", + "blockHash": "0x5f60440279523aa63e7373c9da8f68355dfb8e936f1f4cd67d0157017ec9feb4", + "blockNumber": "0x3180e1d", + "data": "0x00000000000000000000000000000000000000000000090e69ee9efe67253a99", + "logIndex": "0x7b", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xcc2ba89fb9e92c3eab07a6a40e330096c60442af141f585e4f956207d31983b0", + "transactionIndex": "0x1e" + }, + { + "address": "0x12c3c70f09cc9969251fe5aacc9e8de53c6c770d", + "blockHash": "0x98b58c1886992e67d31cfef3b6dd15ba72c0bd979229545d37cb4c5f001de0c2", + "blockNumber": "0x3445283", + "data": "0x", + "logIndex": "0x95", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692", + "0x000000000000000000000000000000000000000000000000000000000000000a" + ], + "transactionHash": "0xd7ecf88bf8919c93839d9d41a85bd58a3235640db5599206ce0a1608eb2db87a", + "transactionIndex": "0x23" + }, + { + "address": "0x8ef88e4c7cfbbac1c163f7eddd4b578792201de6", + "blockHash": "0xeabe6a51fbc62123983e7f03dd4593d7e4a7cc6f3bdf2f6819ebba168507de5e", + "blockNumber": "0x349d0ae", + "data": "0x", + "logIndex": "0x93", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692", + "0x00000000000000000000000000000000000000000000000000000000000174f4" + ], + "transactionHash": "0x11b252f6171c21ca6785aad77a673a31867fad27ae8de9fd771db92d456c07ed", + "transactionIndex": "0x25" + }, + { + "address": "0xafc3b733a6444c42d78efa7c6ab87bb529e5f124", + "blockHash": "0xb10a69130294fc74de55561ccc451e12a8d15a469b5805647f9b39c0ad6b6bca", + "blockNumber": "0x34c3d52", + "data": "0x00000000000000000000000000000000000000000000021e19e0c9bab2400000", + "logIndex": "0x18c", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x8c5a920cd12a7aed46db1b6cae78fa269cb36739c78fc19917e615fb4d24e365", + "transactionIndex": "0x38" + }, + { + "address": "0x00ec78891b8bf2ed3252a68efe428754622c7e94", + "blockHash": "0x63b14d402363460a002ff7668067bea36528aa95044b7db06d16617bb9f4f28e", + "blockNumber": "0x34e4184", + "data": "0x000000000000000000000000000000000000000000000a968163f0a57b400000", + "logIndex": "0x2e0", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x714c0f7561ba1824d993d03e06866eb07f51a8e8180d0cacc0c206c7c1eb1488", + "transactionIndex": "0x62" + }, + { + "address": "0x51771583fe845575774089a9ce728fad40cb3678", + "blockHash": "0xf96f2901ee58c80074b8b8be7e031b8131e0e65c64ec6df736f6bde6edf3bbc8", + "blockNumber": "0x360a02b", + "data": "0x000000000000000000000000000000000000000000000a968163f0a57b400000", + "logIndex": "0x465", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x252b5e8b7d4c8a21fb33d7209be98a1f308f1466f5553c75fabfcd13c3bc7525", + "transactionIndex": "0x3a" + }, + { + "address": "0x8ad0f298360b709a5ad9df7e82478e97a45ade3d", + "blockHash": "0x53192809f053e7e89b3055dde57f4762224f86a8c387553368d1a6c686f1578c", + "blockNumber": "0x361e30e", + "data": "0x0000000000000000000000000000000000000000000000000de0b6b3a7640000", + "logIndex": "0xb22", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x2a230e9a4c6fb8644d60662517acdfd2fcc28abbe57b8aa62d1507b35f7206e8", + "transactionIndex": "0x71" + }, + { + "address": "0xc65fd1815c8dec432a983f5429010108933f8905", + "blockHash": "0xd12418a45fa24bf5b0ba6c193709d535e270864bc035a1681d28bf0b62ec7adc", + "blockNumber": "0x36c1471", + "data": "0x0000000000000000000000000000000000000000000000008ac7230489e80000", + "logIndex": "0x28d", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xc426c479d27b9f1e3124a9c8ccc40b3818a99a6c88e8e3d9c0f3b3a4680edb2a", + "transactionIndex": "0x90" + }, + { + "address": "0x958d208cdf087843e9ad98d23823d32e17d723a1", + "blockHash": "0xa5f0a66ea4efbdf31f2ea9169859739d578d1a921187638a87c6b44923677945", + "blockNumber": "0x371357d", + "data": "0x000000000000000000000000000000000000000000000202433aaf9694bbd57c", + "logIndex": "0x115", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x24dd9c5822e817a76166b80865558147c8023bc824647b3edf7b5d7ffaf01416", + "transactionIndex": "0x32" + }, + { + "address": "0x160f9d8a9ed3618aa2d5ff2c232f8a77964085be", + "blockHash": "0x35629568993d643b4872767e126f77b977cb3a22cf5cf2cb7bd641d824bb5967", + "blockNumber": "0x3959bbb", + "data": "0x0000000000000000000000000000000000000000000000004563918244f40000", + "logIndex": "0x495", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x13eacc672ad28b66ad2149c70db6dd8c947489bf8e729543a31a6aa2cfcf68c2", + "transactionIndex": "0x2b" + }, + { + "address": "0x65b6917801429fed7c41dfa32ba61635f39e1159", + "blockHash": "0xfaa3d27fdccea926caa830709ec4e354805985d84752d87b3f7e789a7c92fc0e", + "blockNumber": "0x3aa45e1", + "data": "0x0000000000000000000000000000000000000000000000000000000000000001", + "logIndex": "0x31b", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x4ee65848d22be8b15456fff3635d1a2a4659944f510fe4df57e7e1f4f59eac41", + "transactionIndex": "0x3f" + }, + { + "address": "0x8ef88e4c7cfbbac1c163f7eddd4b578792201de6", + "blockHash": "0x7546e44afda35bcbdf35c0144d6d03057b82f8f4a0f5754fa6730ccf0d854c45", + "blockNumber": "0x3e04a79", + "data": "0x", + "logIndex": "0x19b", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692", + "0x0000000000000000000000000000000000000000000000000000000000023357" + ], + "transactionHash": "0x53c59dbbd68fc713f4bf673c2bddd148b7e94577996a9b67e6997474d49e9355", + "transactionIndex": "0x4a" + }, + { + "address": "0xa1c3e15b3307b04067e843d3bfaf3cead5b51cb7", + "blockHash": "0xd0d04abc6f673d820a20473ba95472af0596359fd2e3bb7a6119110f8689bcd1", + "blockNumber": "0x3e04bd1", + "data": "0x00000000000000000000000000000000000000000000001fb429863dcc2c6f8c", + "logIndex": "0x585", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xb662461f0dab57b67933f4d3b08884a270f33ae8be4cb857d86b3a633f23f859", + "transactionIndex": "0x6f" + }, + { + "address": "0x8ef88e4c7cfbbac1c163f7eddd4b578792201de6", + "blockHash": "0xcb8ffd00368daec54b50b77b57ae8af7ed74900f4f63e2a933d0b6e198983e9a", + "blockNumber": "0x3e04c21", + "data": "0x", + "logIndex": "0x3a2", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692", + "0x000000000000000000000000000000000000000000000000000000000002335e" + ], + "transactionHash": "0x19b90326ce0383cc706937f155294d9700565c1832dbff4cf2e3a6f76ba93a55", + "transactionIndex": "0x7e" + }, + { + "address": "0x04d521e2c414e6d898c6f2599fdd863edf49e247", + "blockHash": "0x5a7e6e82048fe13463d41bf84f0a1cbf9582305bc4724bb5ab645753f41fa01d", + "blockNumber": "0x3e04eb4", + "data": "0x00000000000000000000000000000000000000000000000000000004179d7148", + "logIndex": "0x248", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0xdeda087909b82d7054b3473864bbcc98fe99189c97895a400dc780dd751af6cf", + "transactionIndex": "0x3c" + }, + { + "address": "0xf626514a3b5b7670e5d3cb2b6533e5eb4b3a9e9c", + "blockHash": "0xcb7bf3a5a08e50c85c4605a11f7d53e9eea7f7b311332db253d025b30b62fb6a", + "blockNumber": "0x3e050d1", + "data": "0x00000000000000000000000000000000000000000000035c28628dde4d74910c", + "logIndex": "0x1b2", + "removed": false, + "topics": [ + "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000b1c95ac3fcfb2a21a79ba5f95cce0ff2237f1692" + ], + "transactionHash": "0x784e47957bb5c0f20b04dfa67946da7bf8edad9631f6eb8dc1333176d26fc55c", + "transactionIndex": "0x63" + } + ] + }, + "c1dda7e2260a7fc353d4473e08b5b9db": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000003" + }, + "1a833166a906b32a76bd44fd3d43de08": { + "result": "0x00000000000000000000000000000000000000000000000000000000000174f4" + }, + "8d4031059a2555064047a8ff8be63247": { + "result": "0x000000000000000000000000000000000000000000000000000000000002335e" + }, + "8aa96130108ad7869843512ec93d9470": { + "result": "0x0000000000000000000000000000000000000000000000000000000000023357" + }, + "ba310957d4b4e49b6f4cd43965f9f2ac": { + "result": "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000d500b1d8e8ef31e21c99d1db9a6444d3adf1270000000000000000000000000172370d5cd63279efa6d502dab29171933a610affffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffb1400000000000000000000000000000000000000000000000000000000000022b00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ac49e51be9f8663428fc470c298aea2000000000000000000000000000000000fb0abd75f20fa2ba69565dc6f44ba7a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "cc27fc82591918c74ebf9a312049daba": { + "result": "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002791bca1f2de4661ed88a30c99a7a9449aa84174000000000000000000000000b5c064f955d8e7f38fe0460c556a72987494ee17000000000000000000000000000000000000000000000000000000000004a6dc000000000000000000000000000000000000000000000000000000000004c1d000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000065871677f941818001732c37d30000000000000000000000000008171793378ac8854b0ce7202dff74d2f97eaf00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "e0177b5ba064aa61c19a0ab79c2f5808": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000025efae7b0b2866cafb14e8ead333a42eeb2a0b800000000000000000000000003c499c542cef5e3811e1192ce70d8cc03d5c3359fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff2764c00000000000000000000000000000000000000000000000000000000000d89b40000000000000000000000000000000000000000000000000000000000000c8c000000000000000000000000000000000005b6ea650746919b0086c6889e4eac00000000000000000000000000000012369ae9583bff214b3a49aaa6260b1df900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "6e0197cbbdb3f4d59424e743e9f94726": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000006" + }, + "d46b056e05901c95f53af44265a0c092": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000447454d5300000000000000000000000000000000000000000000000000000000" + }, + "b1e8b757056982dae9b12b81414dee86": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000447454d5300000000000000000000000000000000000000000000000000000000" + }, + "4c2395972cf16e9aea457d32ae224db9": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000855534420436f696e000000000000000000000000000000000000000000000000" + }, + "6fe8357c30f76dbce60551e0bc30ef32": { + "result": "0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000045553444300000000000000000000000000000000000000000000000000000000" + }, + "1698537ad7769ae9ce61e1fa7ae923a7": { + "result": "0x0000000000000000000000000000000000000000000000000000000000000006" + }, + "41d815735fd2625d265ec17d75294456": { + "result": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "7395fa0a0c61f713159c358131dbab8b": { + "result": "0x00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000347eb2" + }, + "d0763441238c30f980d1abb9a13d42c3": { + "result": "0x000000000000000000000000000000000000000000000003000000000016ade4000000000000000000000000000000000000000000000000000000540b7d168000000000000000000000000000000000000000000000000000000000674ef01600000000000000000000000000000000000000000000000000000000674ef01b000000000000000000000000000000000000000000000003000000000016ade4" + }, + "094ae249554f8da54594523c3d01017f": { + "result": "0x0000000000000000000000000000000000000fa19ed22c324c8ba6d59855959f" + }, + "56bfa0a22ea83d15e0f5bd3be2c87d23": { + "result": "0x000000000000000000000000000000000000000000e53bc4ee03d8c2ea23b506" + } + } +} diff --git a/packages/adapters-library/src/adapters/quickswap-v3/products/pool/tests/testCases.ts b/packages/adapters-library/src/adapters/quickswap-v3/products/pool/tests/testCases.ts new file mode 100644 index 000000000..98b9e3175 --- /dev/null +++ b/packages/adapters-library/src/adapters/quickswap-v3/products/pool/tests/testCases.ts @@ -0,0 +1,35 @@ +import { Chain } from '../../../../../core/constants/chains' +import { TimePeriod } from '../../../../../core/constants/timePeriod' +import type { TestCase } from '../../../../../types/testCase' + +export const testCases: TestCase[] = [ + { + chainId: Chain.Polygon, + method: 'positions', + key: '1', + input: { + userAddress: '0xB1C95aC3fcFB2A21A79BA5f95Cce0Ff2237f1692', + filterProtocolTokens: ['0x8eF88E4c7CfbbaC1C163f7eddd4B578792201de6'], + filterTokenIds: ['144215'], + }, + + blockNumber: 65031322, + }, + { + chainId: Chain.Polygon, + method: 'positions', + key: '2', + input: { + userAddress: '0x36384b230F079Ef0813B68e3938E1A135d6e7A26', + + filterProtocolTokens: [ + '0x8eF88E4c7CfbbaC1C163f7eddd4B578792201de6', + '0x8eF88E4c7CfbbaC1C163f7eddd4B578792201de6', + ], + + filterTokenIds: ['143872', '144209'], + }, + + blockNumber: 65031322, + }, +] diff --git a/packages/adapters-library/src/adapters/supportedProtocols.ts b/packages/adapters-library/src/adapters/supportedProtocols.ts index dbbd50bec..39a3b6463 100644 --- a/packages/adapters-library/src/adapters/supportedProtocols.ts +++ b/packages/adapters-library/src/adapters/supportedProtocols.ts @@ -153,6 +153,10 @@ import { BalancerV2FarmingAdapter } from './balancer-v2/products/farming/balance import { MendiFinanceStakingAdapter } from './mendi-finance/products/staking/mendiFinanceStakingAdapter' +import { QuickswapV2DQuickAdapter } from './quickswap-v2/products/d-quick/quickswapV2DQuickAdapter' + +import { QuickswapV3PoolAdapter } from './quickswap-v3/products/pool/quickswapV3PoolAdapter' + import { ZerolendVestingAdapter } from './zerolend/products/vesting/zerolendVestingAdapter' export const supportedProtocols: Record< @@ -520,7 +524,11 @@ export const supportedProtocols: Record< }, [Protocol.QuickswapV2]: { - [Chain.Polygon]: [QuickswapV2PoolAdapter], + [Chain.Polygon]: [QuickswapV2PoolAdapter, QuickswapV2DQuickAdapter], + }, + + [Protocol.QuickswapV3]: { + [Chain.Polygon]: [QuickswapV3PoolAdapter], }, [Protocol.Renzo]: {