From 892aa4a4644c2a42430b43e58100f38cf50edce5 Mon Sep 17 00:00:00 2001 From: Bernardo Garces Chapero Date: Thu, 7 Nov 2024 14:01:59 +0000 Subject: [PATCH] aave staking adapter (#370) * aave staking adapter * corrections * test update --- ethereum.db | Bin 8953856 -> 8953856 bytes .../adapters/aave-v3/contracts/StakeToken.ts | 1901 ++++++++ .../aave-v3/contracts/abis/stake-token.json | 1771 ++++++++ .../factories/StakeToken__factory.ts | 1788 ++++++++ .../aave-v3/contracts/factories/index.ts | 1 + .../src/adapters/aave-v3/contracts/index.ts | 2 + .../products/staking/aaveV3StakingAdapter.ts | 217 + .../snapshots/ethereum.positions.stk-gho.json | 71 + .../products/staking/tests/testCases.ts | 17 + .../src/adapters/integration.test.ts | 2 + .../src/adapters/supportedProtocols.ts | 3 + .../newAdapterCommand.test.ts.snap | 3888 ++++++++--------- .../scripts/adapterBuilder/replacements.ts | 18 +- 13 files changed, 7509 insertions(+), 2170 deletions(-) create mode 100644 packages/adapters-library/src/adapters/aave-v3/contracts/StakeToken.ts create mode 100644 packages/adapters-library/src/adapters/aave-v3/contracts/abis/stake-token.json create mode 100644 packages/adapters-library/src/adapters/aave-v3/contracts/factories/StakeToken__factory.ts create mode 100644 packages/adapters-library/src/adapters/aave-v3/products/staking/aaveV3StakingAdapter.ts create mode 100644 packages/adapters-library/src/adapters/aave-v3/products/staking/tests/snapshots/ethereum.positions.stk-gho.json create mode 100644 packages/adapters-library/src/adapters/aave-v3/products/staking/tests/testCases.ts diff --git a/ethereum.db b/ethereum.db index 7c44b9802e6062056a843921731ed43163d40c66..37ec7a95063962663c374e9e1b38347757622ff2 100644 GIT binary patch delta 2854 zcma*p4Nw%<9RTosyYKDZ_X!F{LBzxOv54LW+#QJI?)Xsr0*qq(gbRWo$en_U6~X~# zFVmSO5Nnbj`(ae)?IqW$hp;*4hfT5SoJ0O{i4<(Bo7p|_Wz%6 z+T~g{FDAOR5i@adUhm%Wl)bjPdT(`A?e+_U)2w{7TYZ@^-ZB2l_@+@(-!fLJFJG9F zcwQYd1;@p)|JwmIUbr4XEU9_{+pcKe-k?sxCNX@g;Bgphu_2-xPNnvoXGt~E*-^J+2YmG$O__3 zPDbVi+qQD6BR9`$&9k`OcDv18o|coE=5(ex${jXKnZ=rJwx{P=)2-%xb@jPxm!&w( zZg+9+Q(<(bG?GvCx#^iWOBz{811a;fn%7GsdBp3mz$oeEIc}#V+X^3t&Fi#!a??F8 zmRZt0cDLQ)v|24zv)ySiTk7ho6GQ12MFvas6t3NCg~m`@q$%7Iy+j(xCEmDcklNyP zI&&&4WqIY6GamrjmN}fZoLQ;m_B=;kdbv5<0{>@QDEHE31#p1xXpc0KL*Z_D zFa>qm9=(KqM=bO@CpD?-cw+^k$X-F9(v61_1@ob=NNM8sy!%e`@1 z6a`clSj2f*>RXZ|vU4)ze_6yN6#kh$Y0MQlv~Qz4!zP|%BWd{tf5 zbs~K`-;_Z+9}qK*T5hUg*)z0xxyi;essF80FAR-_m4-O|-`O_(ueE3O8}##a|5S~!Yjj6+l{$xx*M6$fX!oF3wK-^% zorMU{d(q<6)2Oz`RIg@h<2(E!E8LS{NHW`uWO5nf8h$OTeMV^3DhV^x0Y zI$04fZ#-FX8)IQ6i+1kTbxyj@-75u(gJU^KX zk<;=*zi$s|PHpM4@C@r^qEO?+H_ro2(9isRzaQNhpIZ0A{T6-SFO}ZD$<1XCG|4OW z`g-@z#21-lT+bLk6kdaUi07~JuktH-J-J3Cl8qlx)2Pn{FBZOa7#nvpp77=`o4fOe z*x=wJpFH@;Z+!+fC?~Ac1LX^;D7oSW{E2=Zc(#OwmQK^>?Ed%#|>4>W-N;3wb!Xar5* zC7HxDKe-y8!<<3J>+k}XYD9+L87d8F23CJVe@tJcPooLL&8_mO;bx1D4mMToSTNBS z9@JRU9jyAQ83aI!T=iA!(NjpIq`fVT)p9hWz0E1tx3{HeLW!# zYEj;PwC(ukoRbr%5IE>y;g}UT=#o#F>$fA>9Nn0R=*id}>Tu;Tbbc?mxa}Z#8Au=~ LFK&C~qxk;-$jO~| delta 2144 zcmZwJdr(x@9S87x?s?pOU!w9*L2-o;E(*&_jF50eh=PcsQ4tLfABYiwfJ6-#kR^9b zGi^X>j!h$=gC=P^b~6OdOq;Z*HKrs2B_?AAoj@iSV{1YsiPo{Dzuo@RnRa$QJ7>-i#jR*=2kf^o21T~$?4TYRor zH*{p^a-WV-E0G;iG^fKj2Ytx%hH;FjAI57C$uP$1dB^u8!{Zpi!ZAXA48xC-F|JIK zH8$mCC0mi$`^1h1M9Cx>ka_5IL5MlsxDiK7BWEH$UV}AWK3xz%mK!$~@rLPw7XJGA zq8$FK!J_3vH?HsH-whUJim~rWgcZlL%;O5(!B2NJr2cPWU)EHXK;%*x^CPJ!M$|Fd z_PJ$9l5eX+(vaH8O!cA$9rj($rG4PPh`8p`E<1?-d*cr)G=3#rOY)$8 z1{7cdW?%tUU;}pG04fLokAN9qCYS{RK@bQAAz(I`1LlHI5C-Of`5;`N{sp87%fSKM zq&t@oi`RTZWa!S*NJc04aKQFBS=U5xhO_2f_w|yx0s+H=KmVDLj_>H5% zk?WXi|Es*g{(I{g`xbk&?H{IxveS0LR&GnNG3#e0i?t5LSu;@^x*%QQxs%SQi8ZD0$ff6=@2JZ+;TG>%N;gXAQsz(IH={v5w8-;#xI;UaxCS4869 zo%0cqZ%T1|EMl`pkw28L$(!yvUn7vy#V6fFV@UUZRYo>LUQ;WOyZ}G_5cak7DeGe!Sp;Hqinh}oG?B{WFXR-dCh0`Q zU*L22FkXYh(4XZy@_X_t@>W?x4`Aw&Z_2KN@mWjw&faa23fgu5KlxhMYTSF1TKNYP z)Wy5*H%4Jp@pJy&H#DBmix7FbAqyhM_(%KN3OZ2eTg>)rKWO~?IQ>C<{Utps6K25R zwh0=8!uU@o=rVqPf^H$^yU^RYZmTAvV4i;yy7TU2MDp>QbcnzEYHp-px9B&B*phw2 zit{x&Jy3+-rZZ(%~NfJ)%BfK*a#d}6+3Rnsr2g^VzNCQuRCqX*U!E%rR zR)9>91)c&c!77jqa=>bk3)YBHnz#FXmh*}~?LU9qs)?G5dB@Ub`U%HB*1ROU-_$tFp8oAt1j^daq`l{A*m>MDDT>s@7` zqOhy%Dj{hv9k=qPDU#-?JW~dCgL1G3JPY=M3b0R9o~e9o00*$uT&b>F!0aE}Yp7Sm zR#(+g{?T}r1Gn@)$FGlPZ8o*^XVKEf7b8A+YPIIrSh=V6KxuXOriAc}O?VYk#@_U%}IecLhCb_GG$Sz)QdY9+Bxj`d;Y20i;>+Hvj+t diff --git a/packages/adapters-library/src/adapters/aave-v3/contracts/StakeToken.ts b/packages/adapters-library/src/adapters/aave-v3/contracts/StakeToken.ts new file mode 100644 index 000000000..17e0f1184 --- /dev/null +++ b/packages/adapters-library/src/adapters/aave-v3/contracts/StakeToken.ts @@ -0,0 +1,1901 @@ +/* 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 DistributionTypes { + export type AssetConfigInputStruct = { + emissionPerSecond: BigNumberish; + totalStaked: BigNumberish; + underlyingAsset: AddressLike; + }; + + export type AssetConfigInputStructOutput = [ + emissionPerSecond: bigint, + totalStaked: bigint, + underlyingAsset: string + ] & { + emissionPerSecond: bigint; + totalStaked: bigint; + underlyingAsset: string; + }; +} + +export interface StakeTokenInterface extends Interface { + getFunction( + nameOrSignature: + | "CLAIM_HELPER_ROLE" + | "COOLDOWN_ADMIN_ROLE" + | "DOMAIN_SEPARATOR" + | "EMISSION_MANAGER" + | "EXCHANGE_RATE_UNIT" + | "INITIAL_EXCHANGE_RATE" + | "LOWER_BOUND" + | "PRECISION" + | "REWARDS_VAULT" + | "REWARD_TOKEN" + | "SLASH_ADMIN_ROLE" + | "STAKED_TOKEN" + | "UNSTAKE_WINDOW" + | "allowance" + | "approve" + | "assets" + | "balanceOf" + | "claimRewards" + | "claimRewardsAndRedeem" + | "claimRewardsAndRedeemOnBehalf" + | "claimRewardsOnBehalf" + | "claimRoleAdmin" + | "configureAssets" + | "cooldown" + | "cooldownOnBehalfOf" + | "decimals" + | "distributionEnd" + | "eip712Domain" + | "getAdmin" + | "getCooldownSeconds" + | "getExchangeRate" + | "getMaxSlashablePercentage" + | "getPendingAdmin" + | "getTotalRewardsBalance" + | "getUserAssetData" + | "inPostSlashingPeriod" + | "initialize" + | "name" + | "nonces" + | "permit" + | "previewRedeem" + | "previewStake" + | "redeem" + | "redeemOnBehalf" + | "returnFunds" + | "setCooldownSeconds" + | "setDistributionEnd" + | "setMaxSlashablePercentage" + | "setPendingAdmin" + | "settleSlashing" + | "slash" + | "stake" + | "stakeWithPermit" + | "stakerRewardsToClaim" + | "stakersCooldowns" + | "symbol" + | "totalSupply" + | "transfer" + | "transferFrom" + ): FunctionFragment; + + getEvent( + nameOrSignatureOrTopic: + | "Approval" + | "AssetConfigUpdated" + | "AssetIndexUpdated" + | "Cooldown" + | "CooldownSecondsChanged" + | "DistributionEndChanged" + | "EIP712DomainChanged" + | "ExchangeRateChanged" + | "FundsReturned" + | "Initialized" + | "MaxSlashablePercentageChanged" + | "PendingAdminChanged" + | "Redeem" + | "RewardsAccrued" + | "RewardsClaimed" + | "RoleClaimed" + | "Slashed" + | "SlashingExitWindowDurationChanged" + | "SlashingSettled" + | "Staked" + | "Transfer" + | "UserIndexUpdated" + ): EventFragment; + + encodeFunctionData( + functionFragment: "CLAIM_HELPER_ROLE", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "COOLDOWN_ADMIN_ROLE", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "DOMAIN_SEPARATOR", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "EMISSION_MANAGER", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "EXCHANGE_RATE_UNIT", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "INITIAL_EXCHANGE_RATE", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "LOWER_BOUND", + values?: undefined + ): string; + encodeFunctionData(functionFragment: "PRECISION", values?: undefined): string; + encodeFunctionData( + functionFragment: "REWARDS_VAULT", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "REWARD_TOKEN", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "SLASH_ADMIN_ROLE", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "STAKED_TOKEN", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "UNSTAKE_WINDOW", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "allowance", + values: [AddressLike, AddressLike] + ): string; + encodeFunctionData( + functionFragment: "approve", + values: [AddressLike, BigNumberish] + ): string; + encodeFunctionData(functionFragment: "assets", values: [AddressLike]): string; + encodeFunctionData( + functionFragment: "balanceOf", + values: [AddressLike] + ): string; + encodeFunctionData( + functionFragment: "claimRewards", + values: [AddressLike, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "claimRewardsAndRedeem", + values: [AddressLike, BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "claimRewardsAndRedeemOnBehalf", + values: [AddressLike, AddressLike, BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "claimRewardsOnBehalf", + values: [AddressLike, AddressLike, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "claimRoleAdmin", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "configureAssets", + values: [DistributionTypes.AssetConfigInputStruct[]] + ): string; + encodeFunctionData(functionFragment: "cooldown", values?: undefined): string; + encodeFunctionData( + functionFragment: "cooldownOnBehalfOf", + values: [AddressLike] + ): string; + encodeFunctionData(functionFragment: "decimals", values?: undefined): string; + encodeFunctionData( + functionFragment: "distributionEnd", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "eip712Domain", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getAdmin", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "getCooldownSeconds", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getExchangeRate", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getMaxSlashablePercentage", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getPendingAdmin", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "getTotalRewardsBalance", + values: [AddressLike] + ): string; + encodeFunctionData( + functionFragment: "getUserAssetData", + values: [AddressLike, AddressLike] + ): string; + encodeFunctionData( + functionFragment: "inPostSlashingPeriod", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "initialize", + values: [ + string, + string, + AddressLike, + AddressLike, + AddressLike, + BigNumberish, + BigNumberish + ] + ): string; + encodeFunctionData(functionFragment: "name", values?: undefined): string; + encodeFunctionData(functionFragment: "nonces", values: [AddressLike]): string; + encodeFunctionData( + functionFragment: "permit", + values: [ + AddressLike, + AddressLike, + BigNumberish, + BigNumberish, + BigNumberish, + BytesLike, + BytesLike + ] + ): string; + encodeFunctionData( + functionFragment: "previewRedeem", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "previewStake", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "redeem", + values: [AddressLike, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "redeemOnBehalf", + values: [AddressLike, AddressLike, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "returnFunds", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "setCooldownSeconds", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "setDistributionEnd", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "setMaxSlashablePercentage", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "setPendingAdmin", + values: [BigNumberish, AddressLike] + ): string; + encodeFunctionData( + functionFragment: "settleSlashing", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "slash", + values: [AddressLike, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "stake", + values: [AddressLike, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "stakeWithPermit", + values: [BigNumberish, BigNumberish, BigNumberish, BytesLike, BytesLike] + ): string; + encodeFunctionData( + functionFragment: "stakerRewardsToClaim", + values: [AddressLike] + ): string; + encodeFunctionData( + functionFragment: "stakersCooldowns", + values: [AddressLike] + ): string; + encodeFunctionData(functionFragment: "symbol", values?: undefined): string; + encodeFunctionData( + functionFragment: "totalSupply", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "transfer", + values: [AddressLike, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "transferFrom", + values: [AddressLike, AddressLike, BigNumberish] + ): string; + + decodeFunctionResult( + functionFragment: "CLAIM_HELPER_ROLE", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "COOLDOWN_ADMIN_ROLE", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "DOMAIN_SEPARATOR", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "EMISSION_MANAGER", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "EXCHANGE_RATE_UNIT", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "INITIAL_EXCHANGE_RATE", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "LOWER_BOUND", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "PRECISION", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "REWARDS_VAULT", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "REWARD_TOKEN", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "SLASH_ADMIN_ROLE", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "STAKED_TOKEN", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "UNSTAKE_WINDOW", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "assets", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "claimRewards", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "claimRewardsAndRedeem", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "claimRewardsAndRedeemOnBehalf", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "claimRewardsOnBehalf", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "claimRoleAdmin", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "configureAssets", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "cooldown", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "cooldownOnBehalfOf", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "distributionEnd", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "eip712Domain", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "getAdmin", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "getCooldownSeconds", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getExchangeRate", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getMaxSlashablePercentage", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getPendingAdmin", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getTotalRewardsBalance", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getUserAssetData", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "inPostSlashingPeriod", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "name", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "nonces", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "permit", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "previewRedeem", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "previewStake", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "redeem", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "redeemOnBehalf", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "returnFunds", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "setCooldownSeconds", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "setDistributionEnd", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "setMaxSlashablePercentage", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "setPendingAdmin", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "settleSlashing", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "slash", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "stake", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "stakeWithPermit", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "stakerRewardsToClaim", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "stakersCooldowns", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "totalSupply", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "transferFrom", + 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 AssetConfigUpdatedEvent { + export type InputTuple = [asset: AddressLike, emission: BigNumberish]; + export type OutputTuple = [asset: string, emission: bigint]; + export interface OutputObject { + asset: string; + emission: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace AssetIndexUpdatedEvent { + export type InputTuple = [asset: AddressLike, index: BigNumberish]; + export type OutputTuple = [asset: string, index: bigint]; + export interface OutputObject { + asset: string; + index: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace CooldownEvent { + 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 namespace CooldownSecondsChangedEvent { + export type InputTuple = [cooldownSeconds: BigNumberish]; + export type OutputTuple = [cooldownSeconds: bigint]; + export interface OutputObject { + cooldownSeconds: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace DistributionEndChangedEvent { + export type InputTuple = [endTimestamp: BigNumberish]; + export type OutputTuple = [endTimestamp: bigint]; + export interface OutputObject { + endTimestamp: 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 ExchangeRateChangedEvent { + export type InputTuple = [exchangeRate: BigNumberish]; + export type OutputTuple = [exchangeRate: bigint]; + export interface OutputObject { + exchangeRate: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace FundsReturnedEvent { + export type InputTuple = [amount: BigNumberish]; + export type OutputTuple = [amount: bigint]; + export interface OutputObject { + amount: 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 MaxSlashablePercentageChangedEvent { + export type InputTuple = [newPercentage: BigNumberish]; + export type OutputTuple = [newPercentage: bigint]; + export interface OutputObject { + newPercentage: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace PendingAdminChangedEvent { + export type InputTuple = [newPendingAdmin: AddressLike, role: BigNumberish]; + export type OutputTuple = [newPendingAdmin: string, role: bigint]; + export interface OutputObject { + newPendingAdmin: string; + role: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace RedeemEvent { + export type InputTuple = [ + from: AddressLike, + to: AddressLike, + assets: BigNumberish, + shares: BigNumberish + ]; + export type OutputTuple = [ + from: string, + to: string, + assets: bigint, + shares: bigint + ]; + export interface OutputObject { + from: string; + to: string; + assets: bigint; + shares: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace RewardsAccruedEvent { + 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 namespace RewardsClaimedEvent { + export type InputTuple = [ + from: AddressLike, + to: AddressLike, + amount: BigNumberish + ]; + export type OutputTuple = [from: string, to: string, amount: bigint]; + export interface OutputObject { + from: string; + to: string; + amount: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace RoleClaimedEvent { + export type InputTuple = [newAdmin: AddressLike, role: BigNumberish]; + export type OutputTuple = [newAdmin: string, role: bigint]; + export interface OutputObject { + newAdmin: string; + role: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace SlashedEvent { + export type InputTuple = [destination: AddressLike, amount: BigNumberish]; + export type OutputTuple = [destination: string, amount: bigint]; + export interface OutputObject { + destination: string; + amount: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace SlashingExitWindowDurationChangedEvent { + export type InputTuple = [windowSeconds: BigNumberish]; + export type OutputTuple = [windowSeconds: bigint]; + export interface OutputObject { + windowSeconds: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export namespace SlashingSettledEvent { + 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 StakedEvent { + export type InputTuple = [ + from: AddressLike, + to: AddressLike, + assets: BigNumberish, + shares: BigNumberish + ]; + export type OutputTuple = [ + from: string, + to: string, + assets: bigint, + shares: bigint + ]; + export interface OutputObject { + from: string; + to: string; + assets: bigint; + shares: bigint; + } + 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 UserIndexUpdatedEvent { + export type InputTuple = [ + user: AddressLike, + asset: AddressLike, + index: BigNumberish + ]; + export type OutputTuple = [user: string, asset: string, index: bigint]; + export interface OutputObject { + user: string; + asset: string; + index: bigint; + } + export type Event = TypedContractEvent; + export type Filter = TypedDeferredTopicFilter; + export type Log = TypedEventLog; + export type LogDescription = TypedLogDescription; +} + +export interface StakeToken extends BaseContract { + connect(runner?: ContractRunner | null): StakeToken; + waitForDeployment(): Promise; + + interface: StakeTokenInterface; + + 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; + + CLAIM_HELPER_ROLE: TypedContractMethod<[], [bigint], "view">; + + COOLDOWN_ADMIN_ROLE: TypedContractMethod<[], [bigint], "view">; + + DOMAIN_SEPARATOR: TypedContractMethod<[], [string], "view">; + + EMISSION_MANAGER: TypedContractMethod<[], [string], "view">; + + EXCHANGE_RATE_UNIT: TypedContractMethod<[], [bigint], "view">; + + INITIAL_EXCHANGE_RATE: TypedContractMethod<[], [bigint], "view">; + + LOWER_BOUND: TypedContractMethod<[], [bigint], "view">; + + PRECISION: TypedContractMethod<[], [bigint], "view">; + + REWARDS_VAULT: TypedContractMethod<[], [string], "view">; + + REWARD_TOKEN: TypedContractMethod<[], [string], "view">; + + SLASH_ADMIN_ROLE: TypedContractMethod<[], [bigint], "view">; + + STAKED_TOKEN: TypedContractMethod<[], [string], "view">; + + UNSTAKE_WINDOW: TypedContractMethod<[], [bigint], "view">; + + allowance: TypedContractMethod< + [owner: AddressLike, spender: AddressLike], + [bigint], + "view" + >; + + approve: TypedContractMethod< + [spender: AddressLike, value: BigNumberish], + [boolean], + "nonpayable" + >; + + assets: TypedContractMethod< + [arg0: AddressLike], + [ + [bigint, bigint, bigint] & { + emissionPerSecond: bigint; + lastUpdateTimestamp: bigint; + index: bigint; + } + ], + "view" + >; + + balanceOf: TypedContractMethod<[account: AddressLike], [bigint], "view">; + + claimRewards: TypedContractMethod< + [to: AddressLike, amount: BigNumberish], + [void], + "nonpayable" + >; + + claimRewardsAndRedeem: TypedContractMethod< + [to: AddressLike, claimAmount: BigNumberish, redeemAmount: BigNumberish], + [void], + "nonpayable" + >; + + claimRewardsAndRedeemOnBehalf: TypedContractMethod< + [ + from: AddressLike, + to: AddressLike, + claimAmount: BigNumberish, + redeemAmount: BigNumberish + ], + [void], + "nonpayable" + >; + + claimRewardsOnBehalf: TypedContractMethod< + [from: AddressLike, to: AddressLike, amount: BigNumberish], + [bigint], + "nonpayable" + >; + + claimRoleAdmin: TypedContractMethod< + [role: BigNumberish], + [void], + "nonpayable" + >; + + configureAssets: TypedContractMethod< + [assetsConfigInput: DistributionTypes.AssetConfigInputStruct[]], + [void], + "nonpayable" + >; + + cooldown: TypedContractMethod<[], [void], "nonpayable">; + + cooldownOnBehalfOf: TypedContractMethod< + [from: AddressLike], + [void], + "nonpayable" + >; + + decimals: TypedContractMethod<[], [bigint], "view">; + + distributionEnd: TypedContractMethod<[], [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" + >; + + getAdmin: TypedContractMethod<[role: BigNumberish], [string], "view">; + + getCooldownSeconds: TypedContractMethod<[], [bigint], "view">; + + getExchangeRate: TypedContractMethod<[], [bigint], "view">; + + getMaxSlashablePercentage: TypedContractMethod<[], [bigint], "view">; + + getPendingAdmin: TypedContractMethod<[role: BigNumberish], [string], "view">; + + getTotalRewardsBalance: TypedContractMethod< + [staker: AddressLike], + [bigint], + "view" + >; + + getUserAssetData: TypedContractMethod< + [user: AddressLike, asset: AddressLike], + [bigint], + "view" + >; + + inPostSlashingPeriod: TypedContractMethod<[], [boolean], "view">; + + initialize: TypedContractMethod< + [ + name: string, + symbol: string, + slashingAdmin: AddressLike, + cooldownPauseAdmin: AddressLike, + claimHelper: AddressLike, + maxSlashablePercentage: BigNumberish, + cooldownSeconds: BigNumberish + ], + [void], + "nonpayable" + >; + + name: TypedContractMethod<[], [string], "view">; + + nonces: TypedContractMethod<[owner: AddressLike], [bigint], "view">; + + permit: TypedContractMethod< + [ + owner: AddressLike, + spender: AddressLike, + value: BigNumberish, + deadline: BigNumberish, + v: BigNumberish, + r: BytesLike, + s: BytesLike + ], + [void], + "nonpayable" + >; + + previewRedeem: TypedContractMethod<[shares: BigNumberish], [bigint], "view">; + + previewStake: TypedContractMethod<[assets: BigNumberish], [bigint], "view">; + + redeem: TypedContractMethod< + [to: AddressLike, amount: BigNumberish], + [void], + "nonpayable" + >; + + redeemOnBehalf: TypedContractMethod< + [from: AddressLike, to: AddressLike, amount: BigNumberish], + [void], + "nonpayable" + >; + + returnFunds: TypedContractMethod< + [amount: BigNumberish], + [void], + "nonpayable" + >; + + setCooldownSeconds: TypedContractMethod< + [cooldownSeconds: BigNumberish], + [void], + "nonpayable" + >; + + setDistributionEnd: TypedContractMethod< + [newDistributionEnd: BigNumberish], + [void], + "nonpayable" + >; + + setMaxSlashablePercentage: TypedContractMethod< + [percentage: BigNumberish], + [void], + "nonpayable" + >; + + setPendingAdmin: TypedContractMethod< + [role: BigNumberish, newPendingAdmin: AddressLike], + [void], + "nonpayable" + >; + + settleSlashing: TypedContractMethod<[], [void], "nonpayable">; + + slash: TypedContractMethod< + [destination: AddressLike, amount: BigNumberish], + [bigint], + "nonpayable" + >; + + stake: TypedContractMethod< + [to: AddressLike, amount: BigNumberish], + [void], + "nonpayable" + >; + + stakeWithPermit: TypedContractMethod< + [ + amount: BigNumberish, + deadline: BigNumberish, + v: BigNumberish, + r: BytesLike, + s: BytesLike + ], + [void], + "nonpayable" + >; + + stakerRewardsToClaim: TypedContractMethod< + [arg0: AddressLike], + [bigint], + "view" + >; + + stakersCooldowns: TypedContractMethod< + [arg0: AddressLike], + [[bigint, bigint] & { timestamp: bigint; amount: bigint }], + "view" + >; + + symbol: TypedContractMethod<[], [string], "view">; + + totalSupply: TypedContractMethod<[], [bigint], "view">; + + transfer: TypedContractMethod< + [to: AddressLike, value: BigNumberish], + [boolean], + "nonpayable" + >; + + transferFrom: TypedContractMethod< + [from: AddressLike, to: AddressLike, value: BigNumberish], + [boolean], + "nonpayable" + >; + + getFunction( + key: string | FunctionFragment + ): T; + + getFunction( + nameOrSignature: "CLAIM_HELPER_ROLE" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "COOLDOWN_ADMIN_ROLE" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "DOMAIN_SEPARATOR" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "EMISSION_MANAGER" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "EXCHANGE_RATE_UNIT" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "INITIAL_EXCHANGE_RATE" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "LOWER_BOUND" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "PRECISION" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "REWARDS_VAULT" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "REWARD_TOKEN" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "SLASH_ADMIN_ROLE" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "STAKED_TOKEN" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "UNSTAKE_WINDOW" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "allowance" + ): TypedContractMethod< + [owner: AddressLike, spender: AddressLike], + [bigint], + "view" + >; + getFunction( + nameOrSignature: "approve" + ): TypedContractMethod< + [spender: AddressLike, value: BigNumberish], + [boolean], + "nonpayable" + >; + getFunction( + nameOrSignature: "assets" + ): TypedContractMethod< + [arg0: AddressLike], + [ + [bigint, bigint, bigint] & { + emissionPerSecond: bigint; + lastUpdateTimestamp: bigint; + index: bigint; + } + ], + "view" + >; + getFunction( + nameOrSignature: "balanceOf" + ): TypedContractMethod<[account: AddressLike], [bigint], "view">; + getFunction( + nameOrSignature: "claimRewards" + ): TypedContractMethod< + [to: AddressLike, amount: BigNumberish], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "claimRewardsAndRedeem" + ): TypedContractMethod< + [to: AddressLike, claimAmount: BigNumberish, redeemAmount: BigNumberish], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "claimRewardsAndRedeemOnBehalf" + ): TypedContractMethod< + [ + from: AddressLike, + to: AddressLike, + claimAmount: BigNumberish, + redeemAmount: BigNumberish + ], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "claimRewardsOnBehalf" + ): TypedContractMethod< + [from: AddressLike, to: AddressLike, amount: BigNumberish], + [bigint], + "nonpayable" + >; + getFunction( + nameOrSignature: "claimRoleAdmin" + ): TypedContractMethod<[role: BigNumberish], [void], "nonpayable">; + getFunction( + nameOrSignature: "configureAssets" + ): TypedContractMethod< + [assetsConfigInput: DistributionTypes.AssetConfigInputStruct[]], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "cooldown" + ): TypedContractMethod<[], [void], "nonpayable">; + getFunction( + nameOrSignature: "cooldownOnBehalfOf" + ): TypedContractMethod<[from: AddressLike], [void], "nonpayable">; + getFunction( + nameOrSignature: "decimals" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "distributionEnd" + ): TypedContractMethod<[], [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: "getAdmin" + ): TypedContractMethod<[role: BigNumberish], [string], "view">; + getFunction( + nameOrSignature: "getCooldownSeconds" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "getExchangeRate" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "getMaxSlashablePercentage" + ): TypedContractMethod<[], [bigint], "view">; + getFunction( + nameOrSignature: "getPendingAdmin" + ): TypedContractMethod<[role: BigNumberish], [string], "view">; + getFunction( + nameOrSignature: "getTotalRewardsBalance" + ): TypedContractMethod<[staker: AddressLike], [bigint], "view">; + getFunction( + nameOrSignature: "getUserAssetData" + ): TypedContractMethod< + [user: AddressLike, asset: AddressLike], + [bigint], + "view" + >; + getFunction( + nameOrSignature: "inPostSlashingPeriod" + ): TypedContractMethod<[], [boolean], "view">; + getFunction( + nameOrSignature: "initialize" + ): TypedContractMethod< + [ + name: string, + symbol: string, + slashingAdmin: AddressLike, + cooldownPauseAdmin: AddressLike, + claimHelper: AddressLike, + maxSlashablePercentage: BigNumberish, + cooldownSeconds: BigNumberish + ], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "name" + ): TypedContractMethod<[], [string], "view">; + getFunction( + nameOrSignature: "nonces" + ): TypedContractMethod<[owner: AddressLike], [bigint], "view">; + getFunction( + nameOrSignature: "permit" + ): TypedContractMethod< + [ + owner: AddressLike, + spender: AddressLike, + value: BigNumberish, + deadline: BigNumberish, + v: BigNumberish, + r: BytesLike, + s: BytesLike + ], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "previewRedeem" + ): TypedContractMethod<[shares: BigNumberish], [bigint], "view">; + getFunction( + nameOrSignature: "previewStake" + ): TypedContractMethod<[assets: BigNumberish], [bigint], "view">; + getFunction( + nameOrSignature: "redeem" + ): TypedContractMethod< + [to: AddressLike, amount: BigNumberish], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "redeemOnBehalf" + ): TypedContractMethod< + [from: AddressLike, to: AddressLike, amount: BigNumberish], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "returnFunds" + ): TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">; + getFunction( + nameOrSignature: "setCooldownSeconds" + ): TypedContractMethod<[cooldownSeconds: BigNumberish], [void], "nonpayable">; + getFunction( + nameOrSignature: "setDistributionEnd" + ): TypedContractMethod< + [newDistributionEnd: BigNumberish], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "setMaxSlashablePercentage" + ): TypedContractMethod<[percentage: BigNumberish], [void], "nonpayable">; + getFunction( + nameOrSignature: "setPendingAdmin" + ): TypedContractMethod< + [role: BigNumberish, newPendingAdmin: AddressLike], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "settleSlashing" + ): TypedContractMethod<[], [void], "nonpayable">; + getFunction( + nameOrSignature: "slash" + ): TypedContractMethod< + [destination: AddressLike, amount: BigNumberish], + [bigint], + "nonpayable" + >; + getFunction( + nameOrSignature: "stake" + ): TypedContractMethod< + [to: AddressLike, amount: BigNumberish], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "stakeWithPermit" + ): TypedContractMethod< + [ + amount: BigNumberish, + deadline: BigNumberish, + v: BigNumberish, + r: BytesLike, + s: BytesLike + ], + [void], + "nonpayable" + >; + getFunction( + nameOrSignature: "stakerRewardsToClaim" + ): TypedContractMethod<[arg0: AddressLike], [bigint], "view">; + getFunction( + nameOrSignature: "stakersCooldowns" + ): TypedContractMethod< + [arg0: AddressLike], + [[bigint, bigint] & { timestamp: bigint; amount: bigint }], + "view" + >; + getFunction( + nameOrSignature: "symbol" + ): TypedContractMethod<[], [string], "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" + >; + + getEvent( + key: "Approval" + ): TypedContractEvent< + ApprovalEvent.InputTuple, + ApprovalEvent.OutputTuple, + ApprovalEvent.OutputObject + >; + getEvent( + key: "AssetConfigUpdated" + ): TypedContractEvent< + AssetConfigUpdatedEvent.InputTuple, + AssetConfigUpdatedEvent.OutputTuple, + AssetConfigUpdatedEvent.OutputObject + >; + getEvent( + key: "AssetIndexUpdated" + ): TypedContractEvent< + AssetIndexUpdatedEvent.InputTuple, + AssetIndexUpdatedEvent.OutputTuple, + AssetIndexUpdatedEvent.OutputObject + >; + getEvent( + key: "Cooldown" + ): TypedContractEvent< + CooldownEvent.InputTuple, + CooldownEvent.OutputTuple, + CooldownEvent.OutputObject + >; + getEvent( + key: "CooldownSecondsChanged" + ): TypedContractEvent< + CooldownSecondsChangedEvent.InputTuple, + CooldownSecondsChangedEvent.OutputTuple, + CooldownSecondsChangedEvent.OutputObject + >; + getEvent( + key: "DistributionEndChanged" + ): TypedContractEvent< + DistributionEndChangedEvent.InputTuple, + DistributionEndChangedEvent.OutputTuple, + DistributionEndChangedEvent.OutputObject + >; + getEvent( + key: "EIP712DomainChanged" + ): TypedContractEvent< + EIP712DomainChangedEvent.InputTuple, + EIP712DomainChangedEvent.OutputTuple, + EIP712DomainChangedEvent.OutputObject + >; + getEvent( + key: "ExchangeRateChanged" + ): TypedContractEvent< + ExchangeRateChangedEvent.InputTuple, + ExchangeRateChangedEvent.OutputTuple, + ExchangeRateChangedEvent.OutputObject + >; + getEvent( + key: "FundsReturned" + ): TypedContractEvent< + FundsReturnedEvent.InputTuple, + FundsReturnedEvent.OutputTuple, + FundsReturnedEvent.OutputObject + >; + getEvent( + key: "Initialized" + ): TypedContractEvent< + InitializedEvent.InputTuple, + InitializedEvent.OutputTuple, + InitializedEvent.OutputObject + >; + getEvent( + key: "MaxSlashablePercentageChanged" + ): TypedContractEvent< + MaxSlashablePercentageChangedEvent.InputTuple, + MaxSlashablePercentageChangedEvent.OutputTuple, + MaxSlashablePercentageChangedEvent.OutputObject + >; + getEvent( + key: "PendingAdminChanged" + ): TypedContractEvent< + PendingAdminChangedEvent.InputTuple, + PendingAdminChangedEvent.OutputTuple, + PendingAdminChangedEvent.OutputObject + >; + getEvent( + key: "Redeem" + ): TypedContractEvent< + RedeemEvent.InputTuple, + RedeemEvent.OutputTuple, + RedeemEvent.OutputObject + >; + getEvent( + key: "RewardsAccrued" + ): TypedContractEvent< + RewardsAccruedEvent.InputTuple, + RewardsAccruedEvent.OutputTuple, + RewardsAccruedEvent.OutputObject + >; + getEvent( + key: "RewardsClaimed" + ): TypedContractEvent< + RewardsClaimedEvent.InputTuple, + RewardsClaimedEvent.OutputTuple, + RewardsClaimedEvent.OutputObject + >; + getEvent( + key: "RoleClaimed" + ): TypedContractEvent< + RoleClaimedEvent.InputTuple, + RoleClaimedEvent.OutputTuple, + RoleClaimedEvent.OutputObject + >; + getEvent( + key: "Slashed" + ): TypedContractEvent< + SlashedEvent.InputTuple, + SlashedEvent.OutputTuple, + SlashedEvent.OutputObject + >; + getEvent( + key: "SlashingExitWindowDurationChanged" + ): TypedContractEvent< + SlashingExitWindowDurationChangedEvent.InputTuple, + SlashingExitWindowDurationChangedEvent.OutputTuple, + SlashingExitWindowDurationChangedEvent.OutputObject + >; + getEvent( + key: "SlashingSettled" + ): TypedContractEvent< + SlashingSettledEvent.InputTuple, + SlashingSettledEvent.OutputTuple, + SlashingSettledEvent.OutputObject + >; + getEvent( + key: "Staked" + ): TypedContractEvent< + StakedEvent.InputTuple, + StakedEvent.OutputTuple, + StakedEvent.OutputObject + >; + getEvent( + key: "Transfer" + ): TypedContractEvent< + TransferEvent.InputTuple, + TransferEvent.OutputTuple, + TransferEvent.OutputObject + >; + getEvent( + key: "UserIndexUpdated" + ): TypedContractEvent< + UserIndexUpdatedEvent.InputTuple, + UserIndexUpdatedEvent.OutputTuple, + UserIndexUpdatedEvent.OutputObject + >; + + filters: { + "Approval(address,address,uint256)": TypedContractEvent< + ApprovalEvent.InputTuple, + ApprovalEvent.OutputTuple, + ApprovalEvent.OutputObject + >; + Approval: TypedContractEvent< + ApprovalEvent.InputTuple, + ApprovalEvent.OutputTuple, + ApprovalEvent.OutputObject + >; + + "AssetConfigUpdated(address,uint256)": TypedContractEvent< + AssetConfigUpdatedEvent.InputTuple, + AssetConfigUpdatedEvent.OutputTuple, + AssetConfigUpdatedEvent.OutputObject + >; + AssetConfigUpdated: TypedContractEvent< + AssetConfigUpdatedEvent.InputTuple, + AssetConfigUpdatedEvent.OutputTuple, + AssetConfigUpdatedEvent.OutputObject + >; + + "AssetIndexUpdated(address,uint256)": TypedContractEvent< + AssetIndexUpdatedEvent.InputTuple, + AssetIndexUpdatedEvent.OutputTuple, + AssetIndexUpdatedEvent.OutputObject + >; + AssetIndexUpdated: TypedContractEvent< + AssetIndexUpdatedEvent.InputTuple, + AssetIndexUpdatedEvent.OutputTuple, + AssetIndexUpdatedEvent.OutputObject + >; + + "Cooldown(address,uint256)": TypedContractEvent< + CooldownEvent.InputTuple, + CooldownEvent.OutputTuple, + CooldownEvent.OutputObject + >; + Cooldown: TypedContractEvent< + CooldownEvent.InputTuple, + CooldownEvent.OutputTuple, + CooldownEvent.OutputObject + >; + + "CooldownSecondsChanged(uint256)": TypedContractEvent< + CooldownSecondsChangedEvent.InputTuple, + CooldownSecondsChangedEvent.OutputTuple, + CooldownSecondsChangedEvent.OutputObject + >; + CooldownSecondsChanged: TypedContractEvent< + CooldownSecondsChangedEvent.InputTuple, + CooldownSecondsChangedEvent.OutputTuple, + CooldownSecondsChangedEvent.OutputObject + >; + + "DistributionEndChanged(uint256)": TypedContractEvent< + DistributionEndChangedEvent.InputTuple, + DistributionEndChangedEvent.OutputTuple, + DistributionEndChangedEvent.OutputObject + >; + DistributionEndChanged: TypedContractEvent< + DistributionEndChangedEvent.InputTuple, + DistributionEndChangedEvent.OutputTuple, + DistributionEndChangedEvent.OutputObject + >; + + "EIP712DomainChanged()": TypedContractEvent< + EIP712DomainChangedEvent.InputTuple, + EIP712DomainChangedEvent.OutputTuple, + EIP712DomainChangedEvent.OutputObject + >; + EIP712DomainChanged: TypedContractEvent< + EIP712DomainChangedEvent.InputTuple, + EIP712DomainChangedEvent.OutputTuple, + EIP712DomainChangedEvent.OutputObject + >; + + "ExchangeRateChanged(uint216)": TypedContractEvent< + ExchangeRateChangedEvent.InputTuple, + ExchangeRateChangedEvent.OutputTuple, + ExchangeRateChangedEvent.OutputObject + >; + ExchangeRateChanged: TypedContractEvent< + ExchangeRateChangedEvent.InputTuple, + ExchangeRateChangedEvent.OutputTuple, + ExchangeRateChangedEvent.OutputObject + >; + + "FundsReturned(uint256)": TypedContractEvent< + FundsReturnedEvent.InputTuple, + FundsReturnedEvent.OutputTuple, + FundsReturnedEvent.OutputObject + >; + FundsReturned: TypedContractEvent< + FundsReturnedEvent.InputTuple, + FundsReturnedEvent.OutputTuple, + FundsReturnedEvent.OutputObject + >; + + "Initialized(uint64)": TypedContractEvent< + InitializedEvent.InputTuple, + InitializedEvent.OutputTuple, + InitializedEvent.OutputObject + >; + Initialized: TypedContractEvent< + InitializedEvent.InputTuple, + InitializedEvent.OutputTuple, + InitializedEvent.OutputObject + >; + + "MaxSlashablePercentageChanged(uint256)": TypedContractEvent< + MaxSlashablePercentageChangedEvent.InputTuple, + MaxSlashablePercentageChangedEvent.OutputTuple, + MaxSlashablePercentageChangedEvent.OutputObject + >; + MaxSlashablePercentageChanged: TypedContractEvent< + MaxSlashablePercentageChangedEvent.InputTuple, + MaxSlashablePercentageChangedEvent.OutputTuple, + MaxSlashablePercentageChangedEvent.OutputObject + >; + + "PendingAdminChanged(address,uint256)": TypedContractEvent< + PendingAdminChangedEvent.InputTuple, + PendingAdminChangedEvent.OutputTuple, + PendingAdminChangedEvent.OutputObject + >; + PendingAdminChanged: TypedContractEvent< + PendingAdminChangedEvent.InputTuple, + PendingAdminChangedEvent.OutputTuple, + PendingAdminChangedEvent.OutputObject + >; + + "Redeem(address,address,uint256,uint256)": TypedContractEvent< + RedeemEvent.InputTuple, + RedeemEvent.OutputTuple, + RedeemEvent.OutputObject + >; + Redeem: TypedContractEvent< + RedeemEvent.InputTuple, + RedeemEvent.OutputTuple, + RedeemEvent.OutputObject + >; + + "RewardsAccrued(address,uint256)": TypedContractEvent< + RewardsAccruedEvent.InputTuple, + RewardsAccruedEvent.OutputTuple, + RewardsAccruedEvent.OutputObject + >; + RewardsAccrued: TypedContractEvent< + RewardsAccruedEvent.InputTuple, + RewardsAccruedEvent.OutputTuple, + RewardsAccruedEvent.OutputObject + >; + + "RewardsClaimed(address,address,uint256)": TypedContractEvent< + RewardsClaimedEvent.InputTuple, + RewardsClaimedEvent.OutputTuple, + RewardsClaimedEvent.OutputObject + >; + RewardsClaimed: TypedContractEvent< + RewardsClaimedEvent.InputTuple, + RewardsClaimedEvent.OutputTuple, + RewardsClaimedEvent.OutputObject + >; + + "RoleClaimed(address,uint256)": TypedContractEvent< + RoleClaimedEvent.InputTuple, + RoleClaimedEvent.OutputTuple, + RoleClaimedEvent.OutputObject + >; + RoleClaimed: TypedContractEvent< + RoleClaimedEvent.InputTuple, + RoleClaimedEvent.OutputTuple, + RoleClaimedEvent.OutputObject + >; + + "Slashed(address,uint256)": TypedContractEvent< + SlashedEvent.InputTuple, + SlashedEvent.OutputTuple, + SlashedEvent.OutputObject + >; + Slashed: TypedContractEvent< + SlashedEvent.InputTuple, + SlashedEvent.OutputTuple, + SlashedEvent.OutputObject + >; + + "SlashingExitWindowDurationChanged(uint256)": TypedContractEvent< + SlashingExitWindowDurationChangedEvent.InputTuple, + SlashingExitWindowDurationChangedEvent.OutputTuple, + SlashingExitWindowDurationChangedEvent.OutputObject + >; + SlashingExitWindowDurationChanged: TypedContractEvent< + SlashingExitWindowDurationChangedEvent.InputTuple, + SlashingExitWindowDurationChangedEvent.OutputTuple, + SlashingExitWindowDurationChangedEvent.OutputObject + >; + + "SlashingSettled()": TypedContractEvent< + SlashingSettledEvent.InputTuple, + SlashingSettledEvent.OutputTuple, + SlashingSettledEvent.OutputObject + >; + SlashingSettled: TypedContractEvent< + SlashingSettledEvent.InputTuple, + SlashingSettledEvent.OutputTuple, + SlashingSettledEvent.OutputObject + >; + + "Staked(address,address,uint256,uint256)": TypedContractEvent< + StakedEvent.InputTuple, + StakedEvent.OutputTuple, + StakedEvent.OutputObject + >; + Staked: TypedContractEvent< + StakedEvent.InputTuple, + StakedEvent.OutputTuple, + StakedEvent.OutputObject + >; + + "Transfer(address,address,uint256)": TypedContractEvent< + TransferEvent.InputTuple, + TransferEvent.OutputTuple, + TransferEvent.OutputObject + >; + Transfer: TypedContractEvent< + TransferEvent.InputTuple, + TransferEvent.OutputTuple, + TransferEvent.OutputObject + >; + + "UserIndexUpdated(address,address,uint256)": TypedContractEvent< + UserIndexUpdatedEvent.InputTuple, + UserIndexUpdatedEvent.OutputTuple, + UserIndexUpdatedEvent.OutputObject + >; + UserIndexUpdated: TypedContractEvent< + UserIndexUpdatedEvent.InputTuple, + UserIndexUpdatedEvent.OutputTuple, + UserIndexUpdatedEvent.OutputObject + >; + }; +} diff --git a/packages/adapters-library/src/adapters/aave-v3/contracts/abis/stake-token.json b/packages/adapters-library/src/adapters/aave-v3/contracts/abis/stake-token.json new file mode 100644 index 000000000..928a7e59f --- /dev/null +++ b/packages/adapters-library/src/adapters/aave-v3/contracts/abis/stake-token.json @@ -0,0 +1,1771 @@ +[ + { + "inputs": [ + { + "internalType": "string", + "name": "name", + "type": "string" + }, + { + "internalType": "contract IERC20", + "name": "stakedToken", + "type": "address" + }, + { + "internalType": "contract IERC20", + "name": "rewardToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "unstakeWindow", + "type": "uint256" + }, + { + "internalType": "address", + "name": "rewardsVault", + "type": "address" + }, + { + "internalType": "address", + "name": "emissionManager", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "target", + "type": "address" + } + ], + "name": "AddressEmptyCode", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "AddressInsufficientBalance", + "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": "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": "deadline", + "type": "uint256" + } + ], + "name": "ERC2612ExpiredSignature", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "signer", + "type": "address" + }, + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "name": "ERC2612InvalidSigner", + "type": "error" + }, + { + "inputs": [], + "name": "FailedInnerCall", + "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": [], + "name": "InvalidShortString", + "type": "error" + }, + { + "inputs": [], + "name": "NotInitializing", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "uint8", + "name": "bits", + "type": "uint8" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + } + ], + "name": "SafeCastOverflowedUintDowncast", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "SafeERC20FailedOperation", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "string", + "name": "str", + "type": "string" + } + ], + "name": "StringTooLong", + "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": "asset", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "emission", + "type": "uint256" + } + ], + "name": "AssetConfigUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "index", + "type": "uint256" + } + ], + "name": "AssetIndexUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "user", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "Cooldown", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint256", + "name": "cooldownSeconds", + "type": "uint256" + } + ], + "name": "CooldownSecondsChanged", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint256", + "name": "endTimestamp", + "type": "uint256" + } + ], + "name": "DistributionEndChanged", + "type": "event" + }, + { + "anonymous": false, + "inputs": [], + "name": "EIP712DomainChanged", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint216", + "name": "exchangeRate", + "type": "uint216" + } + ], + "name": "ExchangeRateChanged", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "FundsReturned", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint64", + "name": "version", + "type": "uint64" + } + ], + "name": "Initialized", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint256", + "name": "newPercentage", + "type": "uint256" + } + ], + "name": "MaxSlashablePercentageChanged", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "newPendingAdmin", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "role", + "type": "uint256" + } + ], + "name": "PendingAdminChanged", + "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": "assets", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "shares", + "type": "uint256" + } + ], + "name": "Redeem", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "user", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "RewardsAccrued", + "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": "amount", + "type": "uint256" + } + ], + "name": "RewardsClaimed", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "newAdmin", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "role", + "type": "uint256" + } + ], + "name": "RoleClaimed", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "destination", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "Slashed", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint256", + "name": "windowSeconds", + "type": "uint256" + } + ], + "name": "SlashingExitWindowDurationChanged", + "type": "event" + }, + { + "anonymous": false, + "inputs": [], + "name": "SlashingSettled", + "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": "assets", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "shares", + "type": "uint256" + } + ], + "name": "Staked", + "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": "user", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "index", + "type": "uint256" + } + ], + "name": "UserIndexUpdated", + "type": "event" + }, + { + "inputs": [], + "name": "CLAIM_HELPER_ROLE", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "COOLDOWN_ADMIN_ROLE", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "DOMAIN_SEPARATOR", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "EMISSION_MANAGER", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "EXCHANGE_RATE_UNIT", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "INITIAL_EXCHANGE_RATE", + "outputs": [ + { + "internalType": "uint216", + "name": "", + "type": "uint216" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "LOWER_BOUND", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "PRECISION", + "outputs": [ + { + "internalType": "uint8", + "name": "", + "type": "uint8" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "REWARDS_VAULT", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "REWARD_TOKEN", + "outputs": [ + { + "internalType": "contract IERC20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "SLASH_ADMIN_ROLE", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "STAKED_TOKEN", + "outputs": [ + { + "internalType": "contract IERC20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "UNSTAKE_WINDOW", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "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": "", + "type": "address" + } + ], + "name": "assets", + "outputs": [ + { + "internalType": "uint128", + "name": "emissionPerSecond", + "type": "uint128" + }, + { + "internalType": "uint128", + "name": "lastUpdateTimestamp", + "type": "uint128" + }, + { + "internalType": "uint256", + "name": "index", + "type": "uint256" + } + ], + "stateMutability": "view", + "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": "to", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "claimRewards", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "internalType": "uint256", + "name": "claimAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "redeemAmount", + "type": "uint256" + } + ], + "name": "claimRewardsAndRedeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "from", + "type": "address" + }, + { + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "internalType": "uint256", + "name": "claimAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "redeemAmount", + "type": "uint256" + } + ], + "name": "claimRewardsAndRedeemOnBehalf", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "from", + "type": "address" + }, + { + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "claimRewardsOnBehalf", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "role", + "type": "uint256" + } + ], + "name": "claimRoleAdmin", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "uint128", + "name": "emissionPerSecond", + "type": "uint128" + }, + { + "internalType": "uint256", + "name": "totalStaked", + "type": "uint256" + }, + { + "internalType": "address", + "name": "underlyingAsset", + "type": "address" + } + ], + "internalType": "struct DistributionTypes.AssetConfigInput[]", + "name": "assetsConfigInput", + "type": "tuple[]" + } + ], + "name": "configureAssets", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "cooldown", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "from", + "type": "address" + } + ], + "name": "cooldownOnBehalfOf", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "decimals", + "outputs": [ + { + "internalType": "uint8", + "name": "", + "type": "uint8" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "distributionEnd", + "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": "uint256", + "name": "role", + "type": "uint256" + } + ], + "name": "getAdmin", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "getCooldownSeconds", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "getExchangeRate", + "outputs": [ + { + "internalType": "uint216", + "name": "", + "type": "uint216" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "getMaxSlashablePercentage", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "role", + "type": "uint256" + } + ], + "name": "getPendingAdmin", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "staker", + "type": "address" + } + ], + "name": "getTotalRewardsBalance", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "user", + "type": "address" + }, + { + "internalType": "address", + "name": "asset", + "type": "address" + } + ], + "name": "getUserAssetData", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "inPostSlashingPeriod", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "string", + "name": "name", + "type": "string" + }, + { + "internalType": "string", + "name": "symbol", + "type": "string" + }, + { + "internalType": "address", + "name": "slashingAdmin", + "type": "address" + }, + { + "internalType": "address", + "name": "cooldownPauseAdmin", + "type": "address" + }, + { + "internalType": "address", + "name": "claimHelper", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maxSlashablePercentage", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "cooldownSeconds", + "type": "uint256" + } + ], + "name": "initialize", + "outputs": [], + "stateMutability": "nonpayable", + "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": "address", + "name": "owner", + "type": "address" + }, + { + "internalType": "address", + "name": "spender", + "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": "permit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "shares", + "type": "uint256" + } + ], + "name": "previewRedeem", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "assets", + "type": "uint256" + } + ], + "name": "previewStake", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "redeem", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "from", + "type": "address" + }, + { + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "redeemOnBehalf", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "returnFunds", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "cooldownSeconds", + "type": "uint256" + } + ], + "name": "setCooldownSeconds", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "newDistributionEnd", + "type": "uint256" + } + ], + "name": "setDistributionEnd", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "percentage", + "type": "uint256" + } + ], + "name": "setMaxSlashablePercentage", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "role", + "type": "uint256" + }, + { + "internalType": "address", + "name": "newPendingAdmin", + "type": "address" + } + ], + "name": "setPendingAdmin", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "settleSlashing", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "destination", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "slash", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "stake", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "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": "stakeWithPermit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "name": "stakerRewardsToClaim", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "name": "stakersCooldowns", + "outputs": [ + { + "internalType": "uint40", + "name": "timestamp", + "type": "uint40" + }, + { + "internalType": "uint216", + "name": "amount", + "type": "uint216" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "symbol", + "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": "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" + } +] \ No newline at end of file diff --git a/packages/adapters-library/src/adapters/aave-v3/contracts/factories/StakeToken__factory.ts b/packages/adapters-library/src/adapters/aave-v3/contracts/factories/StakeToken__factory.ts new file mode 100644 index 000000000..aa5231a34 --- /dev/null +++ b/packages/adapters-library/src/adapters/aave-v3/contracts/factories/StakeToken__factory.ts @@ -0,0 +1,1788 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Interface, type ContractRunner } from "ethers"; +import type { StakeToken, StakeTokenInterface } from "../StakeToken"; + +const _abi = [ + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "contract IERC20", + name: "stakedToken", + type: "address", + }, + { + internalType: "contract IERC20", + name: "rewardToken", + type: "address", + }, + { + internalType: "uint256", + name: "unstakeWindow", + type: "uint256", + }, + { + internalType: "address", + name: "rewardsVault", + type: "address", + }, + { + internalType: "address", + name: "emissionManager", + type: "address", + }, + ], + stateMutability: "nonpayable", + type: "constructor", + }, + { + inputs: [ + { + internalType: "address", + name: "target", + type: "address", + }, + ], + name: "AddressEmptyCode", + type: "error", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "AddressInsufficientBalance", + 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: "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: "deadline", + type: "uint256", + }, + ], + name: "ERC2612ExpiredSignature", + type: "error", + }, + { + inputs: [ + { + internalType: "address", + name: "signer", + type: "address", + }, + { + internalType: "address", + name: "owner", + type: "address", + }, + ], + name: "ERC2612InvalidSigner", + type: "error", + }, + { + inputs: [], + name: "FailedInnerCall", + 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: [], + name: "InvalidShortString", + type: "error", + }, + { + inputs: [], + name: "NotInitializing", + type: "error", + }, + { + inputs: [ + { + internalType: "uint8", + name: "bits", + type: "uint8", + }, + { + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "SafeCastOverflowedUintDowncast", + type: "error", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + ], + name: "SafeERC20FailedOperation", + type: "error", + }, + { + inputs: [ + { + internalType: "string", + name: "str", + type: "string", + }, + ], + name: "StringTooLong", + 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: "asset", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "emission", + type: "uint256", + }, + ], + name: "AssetConfigUpdated", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "asset", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "index", + type: "uint256", + }, + ], + name: "AssetIndexUpdated", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "user", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "Cooldown", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "cooldownSeconds", + type: "uint256", + }, + ], + name: "CooldownSecondsChanged", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "endTimestamp", + type: "uint256", + }, + ], + name: "DistributionEndChanged", + type: "event", + }, + { + anonymous: false, + inputs: [], + name: "EIP712DomainChanged", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint216", + name: "exchangeRate", + type: "uint216", + }, + ], + name: "ExchangeRateChanged", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "FundsReturned", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint64", + name: "version", + type: "uint64", + }, + ], + name: "Initialized", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "newPercentage", + type: "uint256", + }, + ], + name: "MaxSlashablePercentageChanged", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "newPendingAdmin", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "role", + type: "uint256", + }, + ], + name: "PendingAdminChanged", + 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: "assets", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "shares", + type: "uint256", + }, + ], + name: "Redeem", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "user", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "RewardsAccrued", + 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: "amount", + type: "uint256", + }, + ], + name: "RewardsClaimed", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "newAdmin", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "role", + type: "uint256", + }, + ], + name: "RoleClaimed", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "destination", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "Slashed", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "windowSeconds", + type: "uint256", + }, + ], + name: "SlashingExitWindowDurationChanged", + type: "event", + }, + { + anonymous: false, + inputs: [], + name: "SlashingSettled", + 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: "assets", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "shares", + type: "uint256", + }, + ], + name: "Staked", + 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: "user", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "asset", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "index", + type: "uint256", + }, + ], + name: "UserIndexUpdated", + type: "event", + }, + { + inputs: [], + name: "CLAIM_HELPER_ROLE", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "COOLDOWN_ADMIN_ROLE", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "DOMAIN_SEPARATOR", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "EMISSION_MANAGER", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "EXCHANGE_RATE_UNIT", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "INITIAL_EXCHANGE_RATE", + outputs: [ + { + internalType: "uint216", + name: "", + type: "uint216", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "LOWER_BOUND", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "PRECISION", + outputs: [ + { + internalType: "uint8", + name: "", + type: "uint8", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "REWARDS_VAULT", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "REWARD_TOKEN", + outputs: [ + { + internalType: "contract IERC20", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "SLASH_ADMIN_ROLE", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "STAKED_TOKEN", + outputs: [ + { + internalType: "contract IERC20", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "UNSTAKE_WINDOW", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + 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: "", + type: "address", + }, + ], + name: "assets", + outputs: [ + { + internalType: "uint128", + name: "emissionPerSecond", + type: "uint128", + }, + { + internalType: "uint128", + name: "lastUpdateTimestamp", + type: "uint128", + }, + { + internalType: "uint256", + name: "index", + type: "uint256", + }, + ], + stateMutability: "view", + 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: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "claimRewards", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "claimAmount", + type: "uint256", + }, + { + internalType: "uint256", + name: "redeemAmount", + type: "uint256", + }, + ], + name: "claimRewardsAndRedeem", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "from", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "claimAmount", + type: "uint256", + }, + { + internalType: "uint256", + name: "redeemAmount", + type: "uint256", + }, + ], + name: "claimRewardsAndRedeemOnBehalf", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "from", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "claimRewardsOnBehalf", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "role", + type: "uint256", + }, + ], + name: "claimRoleAdmin", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + components: [ + { + internalType: "uint128", + name: "emissionPerSecond", + type: "uint128", + }, + { + internalType: "uint256", + name: "totalStaked", + type: "uint256", + }, + { + internalType: "address", + name: "underlyingAsset", + type: "address", + }, + ], + internalType: "struct DistributionTypes.AssetConfigInput[]", + name: "assetsConfigInput", + type: "tuple[]", + }, + ], + name: "configureAssets", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "cooldown", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "from", + type: "address", + }, + ], + name: "cooldownOnBehalfOf", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "decimals", + outputs: [ + { + internalType: "uint8", + name: "", + type: "uint8", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "distributionEnd", + 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: "uint256", + name: "role", + type: "uint256", + }, + ], + name: "getAdmin", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "getCooldownSeconds", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "getExchangeRate", + outputs: [ + { + internalType: "uint216", + name: "", + type: "uint216", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "getMaxSlashablePercentage", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "role", + type: "uint256", + }, + ], + name: "getPendingAdmin", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "staker", + type: "address", + }, + ], + name: "getTotalRewardsBalance", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "user", + type: "address", + }, + { + internalType: "address", + name: "asset", + type: "address", + }, + ], + name: "getUserAssetData", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "inPostSlashingPeriod", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "symbol", + type: "string", + }, + { + internalType: "address", + name: "slashingAdmin", + type: "address", + }, + { + internalType: "address", + name: "cooldownPauseAdmin", + type: "address", + }, + { + internalType: "address", + name: "claimHelper", + type: "address", + }, + { + internalType: "uint256", + name: "maxSlashablePercentage", + type: "uint256", + }, + { + internalType: "uint256", + name: "cooldownSeconds", + type: "uint256", + }, + ], + name: "initialize", + outputs: [], + stateMutability: "nonpayable", + 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: "address", + name: "owner", + type: "address", + }, + { + internalType: "address", + name: "spender", + 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: "permit", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "shares", + type: "uint256", + }, + ], + name: "previewRedeem", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "assets", + type: "uint256", + }, + ], + name: "previewStake", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "redeem", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "from", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "redeemOnBehalf", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "returnFunds", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "cooldownSeconds", + type: "uint256", + }, + ], + name: "setCooldownSeconds", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "newDistributionEnd", + type: "uint256", + }, + ], + name: "setDistributionEnd", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "percentage", + type: "uint256", + }, + ], + name: "setMaxSlashablePercentage", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "role", + type: "uint256", + }, + { + internalType: "address", + name: "newPendingAdmin", + type: "address", + }, + ], + name: "setPendingAdmin", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "settleSlashing", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "destination", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "slash", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "stake", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "amount", + 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: "stakeWithPermit", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + name: "stakerRewardsToClaim", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + name: "stakersCooldowns", + outputs: [ + { + internalType: "uint40", + name: "timestamp", + type: "uint40", + }, + { + internalType: "uint216", + name: "amount", + type: "uint216", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "symbol", + 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: "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", + }, +] as const; + +export class StakeToken__factory { + static readonly abi = _abi; + static createInterface(): StakeTokenInterface { + return new Interface(_abi) as StakeTokenInterface; + } + static connect(address: string, runner?: ContractRunner | null): StakeToken { + return new Contract(address, _abi, runner) as unknown as StakeToken; + } +} diff --git a/packages/adapters-library/src/adapters/aave-v3/contracts/factories/index.ts b/packages/adapters-library/src/adapters/aave-v3/contracts/factories/index.ts index 8c7215730..1a154580c 100644 --- a/packages/adapters-library/src/adapters/aave-v3/contracts/factories/index.ts +++ b/packages/adapters-library/src/adapters/aave-v3/contracts/factories/index.ts @@ -3,3 +3,4 @@ /* eslint-disable */ export { IncentivesContract__factory } from "./IncentivesContract__factory"; export { PoolContract__factory } from "./PoolContract__factory"; +export { StakeToken__factory } from "./StakeToken__factory"; diff --git a/packages/adapters-library/src/adapters/aave-v3/contracts/index.ts b/packages/adapters-library/src/adapters/aave-v3/contracts/index.ts index 650056732..50902b2cd 100644 --- a/packages/adapters-library/src/adapters/aave-v3/contracts/index.ts +++ b/packages/adapters-library/src/adapters/aave-v3/contracts/index.ts @@ -3,6 +3,8 @@ /* eslint-disable */ export type { IncentivesContract } from "./IncentivesContract"; export type { PoolContract } from "./PoolContract"; +export type { StakeToken } from "./StakeToken"; export * as factories from "./factories"; export { IncentivesContract__factory } from "./factories/IncentivesContract__factory"; export { PoolContract__factory } from "./factories/PoolContract__factory"; +export { StakeToken__factory } from "./factories/StakeToken__factory"; diff --git a/packages/adapters-library/src/adapters/aave-v3/products/staking/aaveV3StakingAdapter.ts b/packages/adapters-library/src/adapters/aave-v3/products/staking/aaveV3StakingAdapter.ts new file mode 100644 index 000000000..5bc1a30c2 --- /dev/null +++ b/packages/adapters-library/src/adapters/aave-v3/products/staking/aaveV3StakingAdapter.ts @@ -0,0 +1,217 @@ +import { AdaptersController } from '../../../../core/adaptersController' +import { Chain } from '../../../../core/constants/chains' +import { CacheToDb } from '../../../../core/decorators/cacheToDb' +import { CustomJsonRpcProvider } from '../../../../core/provider/CustomJsonRpcProvider' +import { filterMapAsync } from '../../../../core/utils/filters' +import { Helpers } from '../../../../scripts/helpers' +import { + IProtocolAdapter, + ProtocolToken, +} from '../../../../types/IProtocolAdapter' +import { + GetEventsInput, + GetPositionsInput, + GetRewardPositionsInput, + GetTotalValueLockedInput, + MovementsByBlock, + PositionType, + ProtocolAdapterParams, + ProtocolDetails, + ProtocolPosition, + ProtocolTokenTvl, + TokenType, + UnderlyingReward, + UnwrapExchangeRate, + UnwrapInput, +} from '../../../../types/adapter' +import { Erc20Metadata } from '../../../../types/erc20Metadata' +import { Protocol } from '../../../protocols' +import { StakeToken__factory } from '../../contracts' +import { AAVE_ICON_URL } from '../rewards/aaveV3RewardsAdapter' + +type AdditionalMetadata = { + rewardTokens: Erc20Metadata[] +} + +export class AaveV3StakingAdapter implements IProtocolAdapter { + productId = 'staking' + 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 + } + + getProtocolDetails(): ProtocolDetails { + return { + protocolId: this.protocolId, + name: 'Aave v3 Staking', + description: 'AaveV3 defi adapter for Safety Module staking', + siteUrl: 'https://app.aave.com/staking/', + iconUrl: AAVE_ICON_URL, + positionType: PositionType.Staked, + chainId: this.chainId, + productId: this.productId, + } + } + + @CacheToDb + async getProtocolTokens(): Promise[]> { + const protocolTokens = await Promise.all( + [ + '0x4da27a545c0c5B758a6BA100e3a049001de870f5', // stkAAVE + '0x1a88Df1cFe15Af22B3c4c783D4e6F7F9e0C1885d', // stkGHO + '0x9eDA81C21C273a82BE9Bbc19B6A6182212068101', // stkAAVEwstETHBPTv2 + ].map(async (address) => this.helpers.getTokenMetadata(address)), + ) + + return await Promise.all( + protocolTokens.map(async (protocolToken) => { + const stakeToken = StakeToken__factory.connect( + protocolToken.address, + this.provider, + ) + + const [underlyingTokenAddress, rewardTokenAddress] = await Promise.all([ + stakeToken.STAKED_TOKEN(), + stakeToken.REWARD_TOKEN(), + ]) + + const [underlyingToken, rewardToken] = await Promise.all([ + this.helpers.getTokenMetadata(underlyingTokenAddress), + this.helpers.getTokenMetadata(rewardTokenAddress), + ]) + + return { + ...protocolToken, + underlyingTokens: [underlyingToken], + rewardTokens: [rewardToken], + } + }), + ) + } + + 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 getRewardPositions({ + userAddress, + protocolTokenAddress, + blockNumber, + }: GetRewardPositionsInput): Promise { + const protocolToken = this.helpers.getProtocolTokenByAddress({ + protocolTokenAddress, + protocolTokens: await this.getProtocolTokens(), + }) + + if (!protocolToken.rewardTokens) { + return [] + } + + return await filterMapAsync( + protocolToken.rewardTokens, + async (rewardTokenMetadata) => { + const stakeToken = StakeToken__factory.connect( + protocolToken.address, + this.provider, + ) + + const rewardBalance = await stakeToken.getTotalRewardsBalance( + userAddress, + { + blockTag: blockNumber, + }, + ) + + if (rewardBalance === 0n) { + return undefined + } + + return { + ...rewardTokenMetadata, + type: TokenType.UnderlyingClaimable, + balanceRaw: rewardBalance, + } + }, + ) + } + + 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, + }: UnwrapInput): Promise { + return this.helpers.unwrapOneToOne({ + protocolToken: await this.getProtocolTokenByAddress(protocolTokenAddress), + underlyingTokens: ( + await this.getProtocolTokenByAddress(protocolTokenAddress) + ).underlyingTokens, + }) + } +} diff --git a/packages/adapters-library/src/adapters/aave-v3/products/staking/tests/snapshots/ethereum.positions.stk-gho.json b/packages/adapters-library/src/adapters/aave-v3/products/staking/tests/snapshots/ethereum.positions.stk-gho.json new file mode 100644 index 000000000..0eeff7acf --- /dev/null +++ b/packages/adapters-library/src/adapters/aave-v3/products/staking/tests/snapshots/ethereum.positions.stk-gho.json @@ -0,0 +1,71 @@ +{ + "blockNumber": 21136131, + "latency": "Latency: 1.787 seconds", + "aggregatedValues": ["USD389,150.47"], + "snapshot": [ + { + "protocolId": "aave-v3", + "name": "Aave v3 Staking", + "description": "AaveV3 defi adapter for Safety Module staking", + "siteUrl": "https://app.aave.com/staking/", + "iconUrl": "https://cryptologos.cc/logos/aave-aave-logo.png", + "positionType": "stake", + "chainId": 1, + "productId": "staking", + "chainName": "ethereum", + "success": true, + "tokens": [ + { + "address": "0x1a88Df1cFe15Af22B3c4c783D4e6F7F9e0C1885d", + "name": "stk GHO", + "symbol": "stkGHO", + "decimals": 18, + "balanceRaw": "386984197341887736805015n", + "type": "protocol", + "tokens": [ + { + "address": "0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9", + "name": "Aave Token", + "symbol": "AAVE", + "decimals": 18, + "type": "underlying-claimable", + "balanceRaw": "11644419193456656219n", + "balance": 11.644419193456656, + "price": 182.98103348656943, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/ethereum/assets/0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9/logo.png" + }, + { + "address": "0x40D16FC0246aD3160Ccc09B8D0D3A2cD28aE6C2f", + "name": "Gho Token", + "symbol": "GHO", + "decimals": 18, + "type": "underlying", + "balanceRaw": "386984197341887736805015n", + "balance": 386984.19734188775, + "price": 1.0000918951901496, + "iconUrl": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/ethereum/assets/0x40D16FC0246aD3160Ccc09B8D0D3A2cD28aE6C2f/logo.png" + } + ], + "balance": 386984.19734188775 + } + ] + } + ], + "rpcResponses": { + "2d9e20727fe7076c64cdb0e9eefb83d5": { + "result": "0x0000000000000000000000000000000000000000000051f27493604bd37b7697" + }, + "386fb807616c3892bc7920d682f3f37a": { + "result": "0x000000000000000000000000000000000000000000000000a199498fc9b97f5b" + }, + "731ce42c7bf681cde66ce61e5f845885": { + "result": "0x00000000000000000000000000000000000000000000000700000000000006e90000000000000000000000000000000000000000000000000000004190af6cd000000000000000000000000000000000000000000000000000000000672cb65400000000000000000000000000000000000000000000000000000000672cb66300000000000000000000000000000000000000000000000700000000000006e9" + }, + "a527f1dc81f463bf406299c2a6112af0": { + "result": "0x00000000000000000000000000000000000000000000000000014300d9716556" + }, + "540e67fcfa7c02400c79a292fc5da6ca": { + "result": "0x00000000000000000000000000000000000000000000000000e6da0cd3b408b2" + } + } +} diff --git a/packages/adapters-library/src/adapters/aave-v3/products/staking/tests/testCases.ts b/packages/adapters-library/src/adapters/aave-v3/products/staking/tests/testCases.ts new file mode 100644 index 000000000..5caa79d39 --- /dev/null +++ b/packages/adapters-library/src/adapters/aave-v3/products/staking/tests/testCases.ts @@ -0,0 +1,17 @@ +import { Chain } from '../../../../../core/constants/chains' +import type { TestCase } from '../../../../../types/testCase' + +export const testCases: TestCase[] = [ + { + key: 'stkGHO', + chainId: Chain.Ethereum, + method: 'positions', + + input: { + userAddress: '0x10fd41ec6FDFE7f9C7Cc7c12DC4f0B4e77659BfA', + filterProtocolTokens: ['0x1a88Df1cFe15Af22B3c4c783D4e6F7F9e0C1885d'], + }, + + blockNumber: 21136131, + }, +] diff --git a/packages/adapters-library/src/adapters/integration.test.ts b/packages/adapters-library/src/adapters/integration.test.ts index 97f14315d..94a1d4c21 100644 --- a/packages/adapters-library/src/adapters/integration.test.ts +++ b/packages/adapters-library/src/adapters/integration.test.ts @@ -19,6 +19,7 @@ import { testCases as aaveV2StableDebtTokenTestCases } from './aave-v2/products/ import { testCases as aaveV2VariableDebtTokenTestCases } from './aave-v2/products/variable-debt-token/tests/testCases' import { testCases as aaveV3ATokenTestCases } from './aave-v3/products/a-token/tests/testCases' import { testCases as aaveV3StableDebtTokenTestCases } from './aave-v3/products/stable-debt-token/tests/testCases' +import { testCases as aaveV3StakingTestCases } from './aave-v3/products/staking/tests/testCases' import { testCases as aaveV3VariableDebtTokenTestCases } from './aave-v3/products/variable-debt-token/tests/testCases' import { testCases as angleProtocolSavingsTestCases } from './angle-protocol/products/savings/tests/testCases' import { testCases as beefyCowTokenTestCases } from './beefy/products/cow-token/tests/testCases' @@ -140,6 +141,7 @@ const allTestCases: Record> = { [Protocol.AaveV3]: { ['a-token']: aaveV3ATokenTestCases, ['stable-debt-token']: aaveV3StableDebtTokenTestCases, + ['staking']: aaveV3StakingTestCases, ['variable-debt-token']: aaveV3VariableDebtTokenTestCases, }, [Protocol.AngleProtocol]: { diff --git a/packages/adapters-library/src/adapters/supportedProtocols.ts b/packages/adapters-library/src/adapters/supportedProtocols.ts index c5b7f5795..f7972823b 100644 --- a/packages/adapters-library/src/adapters/supportedProtocols.ts +++ b/packages/adapters-library/src/adapters/supportedProtocols.ts @@ -134,6 +134,8 @@ import { GmxFarmingAdapter } from './gmx/products/farming/gmxFarmingAdapter' import { GmxVestingAdapter } from './gmx/products/vesting/gmxVestingAdapter' +import { AaveV3StakingAdapter } from './aave-v3/products/staking/aaveV3StakingAdapter' + export const supportedProtocols: Record< Protocol, Partial< @@ -164,6 +166,7 @@ export const supportedProtocols: Record< AaveV3StableDebtTokenPoolAdapter, AaveV3VariableDebtTokenPoolAdapter, AaveV3RewardsAdapter, + AaveV3StakingAdapter, ], [Chain.Polygon]: [ AaveV3ATokenPoolAdapter, diff --git a/packages/adapters-library/src/scripts/adapterBuilder/__snapshots__/newAdapterCommand.test.ts.snap b/packages/adapters-library/src/scripts/adapterBuilder/__snapshots__/newAdapterCommand.test.ts.snap index 57a0c56af..0da8d81ce 100644 --- a/packages/adapters-library/src/scripts/adapterBuilder/__snapshots__/newAdapterCommand.test.ts.snap +++ b/packages/adapters-library/src/scripts/adapterBuilder/__snapshots__/newAdapterCommand.test.ts.snap @@ -1239963,11 +1239963,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1240188,11 +1240186,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1240413,11 +1240409,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1240626,11 +1240620,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1240852,11 +1240844,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1241078,11 +1241068,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1241292,11 +1241280,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1241514,11 +1241500,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1241736,11 +1241720,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1241946,11 +1241928,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1242171,11 +1242151,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1242396,11 +1242374,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1242609,11 +1242585,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1242835,11 +1242809,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1243061,11 +1243033,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1243275,11 +1243245,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1243497,11 +1243465,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1243719,11 +1243685,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1243929,11 +1243893,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1244154,11 +1244116,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1244379,11 +1244339,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1244592,11 +1244550,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1244818,11 +1244774,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1245044,11 +1244998,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1245258,11 +1245210,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1245480,11 +1245430,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1245702,11 +1245650,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1245912,7 +1245858,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1245920,7 +1245866,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1246143,7 +1246089,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1246151,7 +1246097,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1246374,7 +1246320,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1246382,7 +1246328,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1246593,7 +1246539,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1246601,7 +1246547,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1246825,7 +1246771,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1246833,7 +1246779,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1247057,7 +1247003,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1247065,7 +1247011,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1247277,7 +1247223,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1247285,7 +1247231,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1247505,7 +1247451,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1247513,7 +1247459,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1247733,7 +1247679,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1247741,7 +1247687,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1247949,7 +1247895,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1247957,7 +1247903,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1248180,7 +1248126,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1248188,7 +1248134,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1248411,7 +1248357,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1248419,7 +1248365,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1248630,7 +1248576,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1248638,7 +1248584,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1248862,7 +1248808,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1248870,7 +1248816,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1249094,7 +1249040,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1249102,7 +1249048,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1249314,7 +1249260,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1249322,7 +1249268,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1249542,7 +1249488,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1249550,7 +1249496,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1249770,7 +1249716,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1249778,7 +1249724,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1249986,7 +1249932,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1249994,7 +1249940,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1250217,7 +1250163,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1250225,7 +1250171,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1250448,7 +1250394,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1250456,7 +1250402,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1250667,7 +1250613,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1250675,7 +1250621,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1250899,7 +1250845,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1250907,7 +1250853,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1251131,7 +1251077,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1251139,7 +1251085,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1251351,7 +1251297,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1251359,7 +1251305,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1251579,7 +1251525,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1251587,7 +1251533,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1251807,7 +1251753,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1251815,7 +1251761,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1252029,14 +1251975,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1252264,14 +1252210,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1252499,14 +1252445,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1252722,14 +1252668,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1252958,14 +1252904,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1253194,14 +1253140,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1253418,14 +1253364,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1253650,14 +1253596,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1253882,14 +1253828,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1254102,14 +1254048,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1254337,14 +1254283,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1254572,14 +1254518,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1254795,14 +1254741,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1255031,14 +1254977,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1255267,14 +1255213,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1255491,14 +1255437,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1255723,14 +1255669,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1255955,14 +1255901,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1256175,14 +1256121,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1256410,14 +1256356,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1256645,14 +1256591,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1256868,14 +1256814,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1257104,14 +1257050,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1257340,14 +1257286,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1257564,14 +1257510,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1257796,14 +1257742,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1258028,14 +1257974,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1258248,7 +1258194,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1258260,7 +1258206,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1258489,7 +1258435,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1258501,7 +1258447,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1258730,7 +1258676,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1258742,7 +1258688,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1258959,7 +1258905,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1258971,7 +1258917,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1259201,7 +1259147,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1259213,7 +1259159,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1259443,7 +1259389,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1259455,7 +1259401,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1259673,7 +1259619,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1259685,7 +1259631,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1259911,7 +1259857,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1259923,7 +1259869,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1260149,7 +1260095,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1260161,7 +1260107,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1260375,7 +1260321,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1260387,7 +1260333,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1260616,7 +1260562,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1260628,7 +1260574,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1260857,7 +1260803,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1260869,7 +1260815,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1261086,7 +1261032,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1261098,7 +1261044,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1261328,7 +1261274,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1261340,7 +1261286,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1261570,7 +1261516,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1261582,7 +1261528,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1261800,7 +1261746,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1261812,7 +1261758,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1262038,7 +1261984,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1262050,7 +1261996,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1262276,7 +1262222,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1262288,7 +1262234,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1262502,7 +1262448,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1262514,7 +1262460,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1262743,7 +1262689,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1262755,7 +1262701,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1262984,7 +1262930,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1262996,7 +1262942,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1263213,7 +1263159,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1263225,7 +1263171,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1263455,7 +1263401,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1263467,7 +1263413,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1263697,7 +1263643,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1263709,7 +1263655,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1263927,7 +1263873,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1263939,7 +1263885,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1264165,7 +1264111,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1264177,7 +1264123,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1264403,7 +1264349,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1264415,7 +1264361,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1295943,11 +1295889,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1296168,11 +1296112,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1296393,11 +1296335,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1296606,11 +1296546,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1296832,11 +1296770,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1297058,11 +1296994,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1297272,11 +1297206,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1297494,11 +1297426,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1297716,11 +1297646,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1297926,11 +1297854,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1298151,11 +1298077,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1298376,11 +1298300,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1298589,11 +1298511,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1298815,11 +1298735,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1299041,11 +1298959,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1299255,11 +1299171,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1299477,11 +1299391,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1299699,11 +1299611,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1299909,11 +1299819,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1300134,11 +1300042,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1300359,11 +1300265,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1300572,11 +1300476,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1300798,11 +1300700,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1301024,11 +1300924,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1301238,11 +1301136,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1301460,11 +1301356,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1301682,11 +1301576,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1301892,7 +1301784,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1301900,7 +1301792,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1302123,7 +1302015,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1302131,7 +1302023,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1302354,7 +1302246,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1302362,7 +1302254,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1302573,7 +1302465,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1302581,7 +1302473,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1302805,7 +1302697,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1302813,7 +1302705,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1303037,7 +1302929,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1303045,7 +1302937,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1303257,7 +1303149,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1303265,7 +1303157,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1303485,7 +1303377,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1303493,7 +1303385,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1303713,7 +1303605,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1303721,7 +1303613,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1303929,7 +1303821,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1303937,7 +1303829,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1304160,7 +1304052,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1304168,7 +1304060,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1304391,7 +1304283,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1304399,7 +1304291,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1304610,7 +1304502,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1304618,7 +1304510,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1304842,7 +1304734,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1304850,7 +1304742,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1305074,7 +1304966,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1305082,7 +1304974,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1305294,7 +1305186,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1305302,7 +1305194,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1305522,7 +1305414,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1305530,7 +1305422,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1305750,7 +1305642,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1305758,7 +1305650,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1305966,7 +1305858,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1305974,7 +1305866,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1306197,7 +1306089,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1306205,7 +1306097,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1306428,7 +1306320,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1306436,7 +1306328,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1306647,7 +1306539,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1306655,7 +1306547,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1306879,7 +1306771,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1306887,7 +1306779,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1307111,7 +1307003,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1307119,7 +1307011,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1307331,7 +1307223,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1307339,7 +1307231,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1307559,7 +1307451,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1307567,7 +1307459,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1307787,7 +1307679,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1307795,7 +1307687,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1308009,14 +1307901,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1308244,14 +1308136,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1308479,14 +1308371,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1308702,14 +1308594,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1308938,14 +1308830,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1309174,14 +1309066,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1309398,14 +1309290,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1309630,14 +1309522,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1309862,14 +1309754,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1310082,14 +1309974,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1310317,14 +1310209,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1310552,14 +1310444,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1310775,14 +1310667,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1311011,14 +1310903,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1311247,14 +1311139,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1311471,14 +1311363,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1311703,14 +1311595,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1311935,14 +1311827,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1312155,14 +1312047,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1312390,14 +1312282,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1312625,14 +1312517,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1312848,14 +1312740,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1313084,14 +1312976,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1313320,14 +1313212,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1313544,14 +1313436,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1313776,14 +1313668,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1314008,14 +1313900,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1314228,7 +1314120,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1314240,7 +1314132,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1314469,7 +1314361,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1314481,7 +1314373,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1314710,7 +1314602,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1314722,7 +1314614,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1314939,7 +1314831,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1314951,7 +1314843,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1315181,7 +1315073,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1315193,7 +1315085,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1315423,7 +1315315,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1315435,7 +1315327,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1315653,7 +1315545,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1315665,7 +1315557,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1315891,7 +1315783,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1315903,7 +1315795,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1316129,7 +1316021,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1316141,7 +1316033,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1316355,7 +1316247,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1316367,7 +1316259,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1316596,7 +1316488,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1316608,7 +1316500,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1316837,7 +1316729,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1316849,7 +1316741,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1317066,7 +1316958,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1317078,7 +1316970,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1317308,7 +1317200,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1317320,7 +1317212,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1317550,7 +1317442,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1317562,7 +1317454,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1317780,7 +1317672,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1317792,7 +1317684,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1318018,7 +1317910,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1318030,7 +1317922,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1318256,7 +1318148,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1318268,7 +1318160,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1318482,7 +1318374,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1318494,7 +1318386,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1318723,7 +1318615,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1318735,7 +1318627,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1318964,7 +1318856,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1318976,7 +1318868,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1319193,7 +1319085,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1319205,7 +1319097,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1319435,7 +1319327,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1319447,7 +1319339,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1319677,7 +1319569,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1319689,7 +1319581,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1319907,7 +1319799,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1319919,7 +1319811,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1320145,7 +1320037,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1320157,7 +1320049,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1320383,7 +1320275,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1320395,7 +1320287,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1351923,11 +1351815,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1352145,11 +1352035,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1352367,11 +1352255,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1352577,11 +1352463,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1352800,11 +1352684,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1353023,11 +1352905,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1353234,11 +1353114,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1353453,11 +1353331,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1353672,11 +1353548,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1353879,11 +1353753,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1354101,11 +1353973,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1354323,11 +1354193,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1354533,11 +1354401,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1354756,11 +1354622,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1354979,11 +1354843,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1355190,11 +1355052,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1355409,11 +1355269,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1355628,11 +1355486,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1355835,11 +1355691,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1356057,11 +1355911,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1356279,11 +1356131,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1356489,11 +1356339,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1356712,11 +1356560,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1356935,11 +1356781,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1357146,11 +1356990,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1357365,11 +1357207,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1357584,11 +1357424,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1357791,7 +1357629,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1357799,7 +1357637,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1358019,7 +1357857,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1358027,7 +1357865,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1358247,7 +1358085,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1358255,7 +1358093,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1358463,7 +1358301,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1358471,7 +1358309,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1358692,7 +1358530,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1358700,7 +1358538,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1358921,7 +1358759,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1358929,7 +1358767,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1359138,7 +1358976,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1359146,7 +1358984,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1359363,7 +1359201,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1359371,7 +1359209,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1359588,7 +1359426,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1359596,7 +1359434,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1359801,7 +1359639,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1359809,7 +1359647,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1360029,7 +1359867,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1360037,7 +1359875,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1360257,7 +1360095,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1360265,7 +1360103,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1360473,7 +1360311,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1360481,7 +1360319,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1360702,7 +1360540,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1360710,7 +1360548,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1360931,7 +1360769,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1360939,7 +1360777,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1361148,7 +1360986,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1361156,7 +1360994,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1361373,7 +1361211,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1361381,7 +1361219,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1361598,7 +1361436,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1361606,7 +1361444,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1361811,7 +1361649,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1361819,7 +1361657,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1362039,7 +1361877,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1362047,7 +1361885,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1362267,7 +1362105,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1362275,7 +1362113,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1362483,7 +1362321,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1362491,7 +1362329,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1362712,7 +1362550,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1362720,7 +1362558,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1362941,7 +1362779,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1362949,7 +1362787,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1363158,7 +1362996,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1363166,7 +1363004,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1363383,7 +1363221,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1363391,7 +1363229,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1363608,7 +1363446,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1363616,7 +1363454,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1363827,14 +1363665,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1364059,14 +1363897,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1364291,14 +1364129,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1364511,14 +1364349,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1364744,14 +1364582,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1364977,14 +1364815,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1365198,14 +1365036,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1365427,14 +1365265,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1365656,14 +1365494,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1365873,14 +1365711,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1366105,14 +1365943,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1366337,14 +1366175,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1366557,14 +1366395,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1366790,14 +1366628,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1367023,14 +1366861,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1367244,14 +1367082,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1367473,14 +1367311,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1367702,14 +1367540,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1367919,14 +1367757,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1368151,14 +1367989,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1368383,14 +1368221,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1368603,14 +1368441,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1368836,14 +1368674,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1369069,14 +1368907,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1369290,14 +1369128,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1369519,14 +1369357,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1369748,14 +1369586,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1369965,7 +1369803,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1369977,7 +1369815,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1370203,7 +1370041,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1370215,7 +1370053,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1370441,7 +1370279,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1370453,7 +1370291,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1370667,7 +1370505,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1370679,7 +1370517,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1370906,7 +1370744,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1370918,7 +1370756,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1371145,7 +1370983,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1371157,7 +1370995,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1371372,7 +1371210,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1371384,7 +1371222,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1371607,7 +1371445,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1371619,7 +1371457,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1371842,7 +1371680,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1371854,7 +1371692,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1372065,7 +1371903,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1372077,7 +1371915,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1372303,7 +1372141,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1372315,7 +1372153,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1372541,7 +1372379,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1372553,7 +1372391,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1372767,7 +1372605,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1372779,7 +1372617,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1373006,7 +1372844,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1373018,7 +1372856,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1373245,7 +1373083,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1373257,7 +1373095,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1373472,7 +1373310,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1373484,7 +1373322,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1373707,7 +1373545,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1373719,7 +1373557,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1373942,7 +1373780,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1373954,7 +1373792,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1374165,7 +1374003,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1374177,7 +1374015,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1374403,7 +1374241,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1374415,7 +1374253,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1374641,7 +1374479,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1374653,7 +1374491,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1374867,7 +1374705,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1374879,7 +1374717,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1375106,7 +1374944,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1375118,7 +1374956,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1375345,7 +1375183,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1375357,7 +1375195,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1375572,7 +1375410,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1375584,7 +1375422,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1375807,7 +1375645,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1375819,7 +1375657,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1376042,7 +1375880,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1376054,7 +1375892,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1407579,11 +1407417,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1407801,11 +1407637,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1408023,11 +1407857,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1408233,11 +1408065,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1408456,11 +1408286,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1408679,11 +1408507,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1408890,11 +1408716,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1409109,11 +1408933,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1409328,11 +1409150,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1409535,11 +1409355,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1409757,11 +1409575,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1409979,11 +1409795,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1410189,11 +1410003,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1410412,11 +1410224,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1410635,11 +1410445,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1410846,11 +1410654,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1411065,11 +1410871,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1411284,11 +1411088,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1411491,11 +1411293,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1411713,11 +1411513,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1411935,11 +1411733,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1412145,11 +1411941,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1412368,11 +1412162,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1412591,11 +1412383,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1412802,11 +1412592,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1413021,11 +1412809,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1413240,11 +1413026,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1413447,7 +1413231,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1413455,7 +1413239,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1413675,7 +1413459,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1413683,7 +1413467,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1413903,7 +1413687,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1413911,7 +1413695,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1414119,7 +1413903,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1414127,7 +1413911,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1414348,7 +1414132,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1414356,7 +1414140,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1414577,7 +1414361,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1414585,7 +1414369,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1414794,7 +1414578,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1414802,7 +1414586,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1415019,7 +1414803,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1415027,7 +1414811,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1415244,7 +1415028,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1415252,7 +1415036,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1415457,7 +1415241,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1415465,7 +1415249,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1415685,7 +1415469,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1415693,7 +1415477,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1415913,7 +1415697,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1415921,7 +1415705,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1416129,7 +1415913,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1416137,7 +1415921,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1416358,7 +1416142,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1416366,7 +1416150,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1416587,7 +1416371,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1416595,7 +1416379,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1416804,7 +1416588,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1416812,7 +1416596,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1417029,7 +1416813,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1417037,7 +1416821,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1417254,7 +1417038,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1417262,7 +1417046,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1417467,7 +1417251,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1417475,7 +1417259,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1417695,7 +1417479,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1417703,7 +1417487,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1417923,7 +1417707,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1417931,7 +1417715,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1418139,7 +1417923,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1418147,7 +1417931,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1418368,7 +1418152,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1418376,7 +1418160,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1418597,7 +1418381,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1418605,7 +1418389,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1418814,7 +1418598,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1418822,7 +1418606,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1419039,7 +1418823,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1419047,7 +1418831,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1419264,7 +1419048,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1419272,7 +1419056,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1419483,14 +1419267,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1419715,14 +1419499,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1419947,14 +1419731,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1420167,14 +1419951,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1420400,14 +1420184,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1420633,14 +1420417,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1420854,14 +1420638,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1421083,14 +1420867,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1421312,14 +1421096,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1421529,14 +1421313,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1421761,14 +1421545,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1421993,14 +1421777,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1422213,14 +1421997,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1422446,14 +1422230,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1422679,14 +1422463,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1422900,14 +1422684,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1423129,14 +1422913,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1423358,14 +1423142,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1423575,14 +1423359,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1423807,14 +1423591,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1424039,14 +1423823,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1424259,14 +1424043,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1424492,14 +1424276,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1424725,14 +1424509,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1424946,14 +1424730,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1425175,14 +1424959,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1425404,14 +1425188,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1425621,7 +1425405,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1425633,7 +1425417,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1425859,7 +1425643,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1425871,7 +1425655,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1426097,7 +1425881,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1426109,7 +1425893,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1426323,7 +1426107,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1426335,7 +1426119,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1426562,7 +1426346,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1426574,7 +1426358,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1426801,7 +1426585,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1426813,7 +1426597,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1427028,7 +1426812,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1427040,7 +1426824,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1427263,7 +1427047,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1427275,7 +1427059,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1427498,7 +1427282,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1427510,7 +1427294,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1427721,7 +1427505,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1427733,7 +1427517,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1427959,7 +1427743,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1427971,7 +1427755,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1428197,7 +1427981,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1428209,7 +1427993,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1428423,7 +1428207,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1428435,7 +1428219,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1428662,7 +1428446,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1428674,7 +1428458,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1428901,7 +1428685,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1428913,7 +1428697,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1429128,7 +1428912,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1429140,7 +1428924,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1429363,7 +1429147,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1429375,7 +1429159,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1429598,7 +1429382,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1429610,7 +1429394,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1429821,7 +1429605,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1429833,7 +1429617,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1430059,7 +1429843,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1430071,7 +1429855,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1430297,7 +1430081,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1430309,7 +1430093,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1430523,7 +1430307,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1430535,7 +1430319,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1430762,7 +1430546,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1430774,7 +1430558,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1431001,7 +1430785,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1431013,7 +1430797,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1431228,7 +1431012,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1431240,7 +1431024,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1431463,7 +1431247,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1431475,7 +1431259,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1431698,7 +1431482,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1431710,7 +1431494,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1463235,11 +1463019,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1463454,11 +1463236,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1463673,11 +1463453,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1463880,11 +1463658,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1464100,11 +1463876,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1464320,11 +1464094,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1464528,11 +1464300,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1464744,11 +1464514,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1464960,11 +1464728,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1465164,11 +1464930,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1465383,11 +1465147,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1465602,11 +1465364,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1465809,11 +1465569,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1466029,11 +1465787,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1466249,11 +1466005,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1466457,11 +1466211,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1466673,11 +1466425,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1466889,11 +1466639,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1467093,11 +1466841,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1467312,11 +1467058,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1467531,11 +1467275,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1467738,11 +1467480,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1467958,11 +1467698,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1468178,11 +1467916,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1468386,11 +1468122,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1468602,11 +1468336,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1468818,11 +1468550,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1469022,7 +1468752,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1469030,7 +1468760,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1469247,7 +1468977,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1469255,7 +1468985,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1469472,7 +1469202,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1469480,7 +1469210,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1469685,7 +1469415,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1469693,7 +1469423,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1469911,7 +1469641,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1469919,7 +1469649,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1470137,7 +1469867,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1470145,7 +1469875,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1470351,7 +1470081,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1470359,7 +1470089,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1470573,7 +1470303,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1470581,7 +1470311,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1470795,7 +1470525,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1470803,7 +1470533,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1471005,7 +1470735,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1471013,7 +1470743,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1471230,7 +1470960,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1471238,7 +1470968,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1471455,7 +1471185,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1471463,7 +1471193,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1471668,7 +1471398,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1471676,7 +1471406,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1471894,7 +1471624,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1471902,7 +1471632,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1472120,7 +1471850,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1472128,7 +1471858,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1472334,7 +1472064,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1472342,7 +1472072,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1472556,7 +1472286,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1472564,7 +1472294,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1472778,7 +1472508,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1472786,7 +1472516,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1472988,7 +1472718,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1472996,7 +1472726,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1473213,7 +1472943,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1473221,7 +1472951,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1473438,7 +1473168,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1473446,7 +1473176,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1473651,7 +1473381,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1473659,7 +1473389,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1473877,7 +1473607,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1473885,7 +1473615,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1474103,7 +1473833,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1474111,7 +1473841,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1474317,7 +1474047,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1474325,7 +1474055,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1474539,7 +1474269,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1474547,7 +1474277,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1474761,7 +1474491,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1474769,7 +1474499,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1474977,14 +1474707,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1475206,14 +1474936,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1475435,14 +1475165,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1475652,14 +1475382,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1475882,14 +1475612,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1476112,14 +1475842,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1476330,14 +1476060,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1476556,14 +1476286,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1476782,14 +1476512,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1476996,14 +1476726,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1477225,14 +1476955,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1477454,14 +1477184,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1477671,14 +1477401,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1477901,14 +1477631,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1478131,14 +1477861,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1478349,14 +1478079,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1478575,14 +1478305,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1478801,14 +1478531,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1479015,14 +1478745,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1479244,14 +1478974,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1479473,14 +1479203,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1479690,14 +1479420,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1479920,14 +1479650,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1480150,14 +1479880,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1480368,14 +1480098,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1480594,14 +1480324,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1480820,14 +1480550,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1481034,7 +1480764,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1481046,7 +1480776,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1481269,7 +1480999,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1481281,7 +1481011,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1481504,7 +1481234,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1481516,7 +1481246,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1481727,7 +1481457,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1481739,7 +1481469,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1481963,7 +1481693,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1481975,7 +1481705,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1482199,7 +1481929,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1482211,7 +1481941,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1482423,7 +1482153,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1482435,7 +1482165,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1482655,7 +1482385,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1482667,7 +1482397,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1482887,7 +1482617,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1482899,7 +1482629,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1483107,7 +1482837,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1483119,7 +1482849,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1483342,7 +1483072,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1483354,7 +1483084,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1483577,7 +1483307,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1483589,7 +1483319,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1483800,7 +1483530,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1483812,7 +1483542,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1484036,7 +1483766,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1484048,7 +1483778,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1484272,7 +1484002,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1484284,7 +1484014,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1484496,7 +1484226,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1484508,7 +1484238,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1484728,7 +1484458,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1484740,7 +1484470,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1484960,7 +1484690,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1484972,7 +1484702,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1485180,7 +1484910,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1485192,7 +1484922,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1485415,7 +1485145,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1485427,7 +1485157,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1485650,7 +1485380,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1485662,7 +1485392,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1485873,7 +1485603,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1485885,7 +1485615,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1486109,7 +1485839,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1486121,7 +1485851,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1486345,7 +1486075,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1486357,7 +1486087,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1486569,7 +1486299,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1486581,7 +1486311,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1486801,7 +1486531,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1486813,7 +1486543,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1487033,7 +1486763,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1487045,7 +1486775,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1518567,11 +1518297,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1518786,11 +1518514,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1519005,11 +1518731,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1519212,11 +1518936,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1519432,11 +1519154,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1519652,11 +1519372,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1519860,11 +1519578,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1520076,11 +1519792,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1520292,11 +1520006,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1520496,11 +1520208,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1520715,11 +1520425,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1520934,11 +1520642,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1521141,11 +1520847,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1521361,11 +1521065,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1521581,11 +1521283,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1521789,11 +1521489,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1522005,11 +1521703,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1522221,11 +1521917,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1522425,11 +1522119,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1522644,11 +1522336,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1522863,11 +1522553,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1523070,11 +1522758,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1523290,11 +1522976,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1523510,11 +1523194,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1523718,11 +1523400,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1523934,11 +1523614,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1524150,11 +1523828,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1524354,7 +1524030,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1524362,7 +1524038,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1524579,7 +1524255,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1524587,7 +1524263,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1524804,7 +1524480,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1524812,7 +1524488,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1525017,7 +1524693,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1525025,7 +1524701,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1525243,7 +1524919,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1525251,7 +1524927,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1525469,7 +1525145,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1525477,7 +1525153,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1525683,7 +1525359,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1525691,7 +1525367,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1525905,7 +1525581,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1525913,7 +1525589,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1526127,7 +1525803,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1526135,7 +1525811,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1526337,7 +1526013,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1526345,7 +1526021,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1526562,7 +1526238,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1526570,7 +1526246,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1526787,7 +1526463,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1526795,7 +1526471,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1527000,7 +1526676,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1527008,7 +1526684,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1527226,7 +1526902,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1527234,7 +1526910,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1527452,7 +1527128,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1527460,7 +1527136,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1527666,7 +1527342,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1527674,7 +1527350,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1527888,7 +1527564,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1527896,7 +1527572,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1528110,7 +1527786,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1528118,7 +1527794,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1528320,7 +1527996,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1528328,7 +1528004,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1528545,7 +1528221,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1528553,7 +1528229,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1528770,7 +1528446,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1528778,7 +1528454,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1528983,7 +1528659,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1528991,7 +1528667,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1529209,7 +1528885,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1529217,7 +1528893,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1529435,7 +1529111,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1529443,7 +1529119,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1529649,7 +1529325,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1529657,7 +1529333,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1529871,7 +1529547,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1529879,7 +1529555,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1530093,7 +1529769,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1530101,7 +1529777,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1530309,14 +1529985,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1530538,14 +1530214,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1530767,14 +1530443,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1530984,14 +1530660,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1531214,14 +1530890,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1531444,14 +1531120,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1531662,14 +1531338,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1531888,14 +1531564,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1532114,14 +1531790,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1532328,14 +1532004,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1532557,14 +1532233,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1532786,14 +1532462,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1533003,14 +1532679,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1533233,14 +1532909,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1533463,14 +1533139,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1533681,14 +1533357,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1533907,14 +1533583,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1534133,14 +1533809,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1534347,14 +1534023,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1534576,14 +1534252,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1534805,14 +1534481,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1535022,14 +1534698,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1535252,14 +1534928,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1535482,14 +1535158,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1535700,14 +1535376,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1535926,14 +1535602,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1536152,14 +1535828,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1536366,7 +1536042,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1536378,7 +1536054,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1536601,7 +1536277,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1536613,7 +1536289,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1536836,7 +1536512,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1536848,7 +1536524,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1537059,7 +1536735,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1537071,7 +1536747,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1537295,7 +1536971,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1537307,7 +1536983,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1537531,7 +1537207,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1537543,7 +1537219,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1537755,7 +1537431,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1537767,7 +1537443,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1537987,7 +1537663,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1537999,7 +1537675,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1538219,7 +1537895,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1538231,7 +1537907,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1538439,7 +1538115,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1538451,7 +1538127,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1538674,7 +1538350,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1538686,7 +1538362,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1538909,7 +1538585,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1538921,7 +1538597,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1539132,7 +1538808,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1539144,7 +1538820,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1539368,7 +1539044,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1539380,7 +1539056,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1539604,7 +1539280,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1539616,7 +1539292,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1539828,7 +1539504,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1539840,7 +1539516,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1540060,7 +1539736,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1540072,7 +1539748,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1540292,7 +1539968,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1540304,7 +1539980,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1540512,7 +1540188,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1540524,7 +1540200,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1540747,7 +1540423,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1540759,7 +1540435,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1540982,7 +1540658,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1540994,7 +1540670,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1541205,7 +1540881,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1541217,7 +1540893,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1541441,7 +1541117,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1541453,7 +1541129,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1541677,7 +1541353,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1541689,7 +1541365,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1541901,7 +1541577,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1541913,7 +1541589,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1542133,7 +1541809,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1542145,7 +1541821,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1542365,7 +1542041,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1542377,7 +1542053,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1573899,11 +1573575,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1574115,11 +1573789,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1574331,11 +1574003,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1574535,11 +1574205,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1574752,11 +1574420,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1574969,11 +1574635,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1575174,11 +1574838,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1575387,11 +1575049,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1575600,11 +1575260,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1575801,11 +1575459,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1576017,11 +1575673,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1576233,11 +1575887,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1576437,11 +1576089,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1576654,11 +1576304,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1576871,11 +1576519,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1577076,11 +1576722,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1577289,11 +1576933,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1577502,11 +1577144,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1577703,11 +1577343,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1577919,11 +1577557,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1578135,11 +1577771,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1578339,11 +1577973,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1578556,11 +1578188,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1578773,11 +1578403,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1578978,11 +1578606,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1579191,11 +1578817,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1579404,11 +1579028,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1579605,7 +1579227,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1579613,7 +1579235,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1579827,7 +1579449,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1579835,7 +1579457,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1580049,7 +1579671,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1580057,7 +1579679,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1580259,7 +1579881,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1580267,7 +1579889,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1580482,7 +1580104,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1580490,7 +1580112,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1580705,7 +1580327,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1580713,7 +1580335,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1580916,7 +1580538,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1580924,7 +1580546,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1581135,7 +1580757,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1581143,7 +1580765,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1581354,7 +1580976,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1581362,7 +1580984,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1581561,7 +1581183,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1581569,7 +1581191,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1581783,7 +1581405,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1581791,7 +1581413,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1582005,7 +1581627,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1582013,7 +1581635,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1582215,7 +1581837,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1582223,7 +1581845,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1582438,7 +1582060,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1582446,7 +1582068,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1582661,7 +1582283,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1582669,7 +1582291,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1582872,7 +1582494,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1582880,7 +1582502,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1583091,7 +1582713,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1583099,7 +1582721,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1583310,7 +1582932,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1583318,7 +1582940,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1583517,7 +1583139,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1583525,7 +1583147,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1583739,7 +1583361,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1583747,7 +1583369,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1583961,7 +1583583,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1583969,7 +1583591,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1584171,7 +1583793,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1584179,7 +1583801,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1584394,7 +1584016,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1584402,7 +1584024,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1584617,7 +1584239,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1584625,7 +1584247,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1584828,7 +1584450,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1584836,7 +1584458,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1585047,7 +1584669,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1585055,7 +1584677,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1585266,7 +1584888,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1585274,7 +1584896,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1585479,14 +1585101,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1585705,14 +1585327,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1585931,14 +1585553,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1586145,14 +1585767,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1586372,14 +1585994,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1586599,14 +1586221,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1586814,14 +1586436,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1587037,14 +1586659,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1587260,14 +1586882,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1587471,14 +1587093,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1587697,14 +1587319,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1587923,14 +1587545,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1588137,14 +1587759,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1588364,14 +1587986,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1588591,14 +1588213,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1588806,14 +1588428,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1589029,14 +1588651,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1589252,14 +1588874,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1589463,14 +1589085,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1589689,14 +1589311,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1589915,14 +1589537,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1590129,14 +1589751,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1590356,14 +1589978,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1590583,14 +1590205,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1590798,14 +1590420,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1591021,14 +1590643,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1591244,14 +1590866,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1591455,7 +1591077,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1591467,7 +1591089,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1591687,7 +1591309,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1591699,7 +1591321,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1591919,7 +1591541,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1591931,7 +1591553,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1592139,7 +1591761,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1592151,7 +1591773,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1592372,7 +1591994,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1592384,7 +1592006,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1592605,7 +1592227,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1592617,7 +1592239,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1592826,7 +1592448,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1592838,7 +1592460,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1593055,7 +1592677,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1593067,7 +1592689,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1593284,7 +1592906,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1593296,7 +1592918,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1593501,7 +1593123,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1593513,7 +1593135,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1593733,7 +1593355,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1593745,7 +1593367,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1593965,7 +1593587,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1593977,7 +1593599,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1594185,7 +1593807,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1594197,7 +1593819,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1594418,7 +1594040,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1594430,7 +1594052,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1594651,7 +1594273,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1594663,7 +1594285,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1594872,7 +1594494,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1594884,7 +1594506,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1595101,7 +1594723,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1595113,7 +1594735,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1595330,7 +1594952,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1595342,7 +1594964,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1595547,7 +1595169,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1595559,7 +1595181,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1595779,7 +1595401,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1595791,7 +1595413,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1596011,7 +1595633,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1596023,7 +1595645,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1596231,7 +1595853,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1596243,7 +1595865,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1596464,7 +1596086,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1596476,7 +1596098,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1596697,7 +1596319,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1596709,7 +1596331,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1596918,7 +1596540,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1596930,7 +1596552,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1597147,7 +1596769,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1597159,7 +1596781,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1597376,7 +1596998,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1597388,7 +1597010,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1628907,11 +1628529,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1629123,11 +1628743,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1629339,11 +1628957,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1629543,11 +1629159,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1629760,11 +1629374,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1629977,11 +1629589,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1630182,11 +1629792,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1630395,11 +1630003,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1630608,11 +1630214,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1630809,11 +1630413,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1631025,11 +1630627,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1631241,11 +1630841,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1631445,11 +1631043,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1631662,11 +1631258,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1631879,11 +1631473,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1632084,11 +1631676,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1632297,11 +1631887,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1632510,11 +1632098,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1632711,11 +1632297,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1632927,11 +1632511,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1633143,11 +1632725,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1633347,11 +1632927,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1633564,11 +1633142,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1633781,11 +1633357,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1633986,11 +1633560,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1634199,11 +1633771,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1634412,11 +1633982,9 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -1634613,7 +1634181,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1634621,7 +1634189,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1634835,7 +1634403,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1634843,7 +1634411,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1635057,7 +1634625,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1635065,7 +1634633,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1635267,7 +1634835,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1635275,7 +1634843,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1635490,7 +1635058,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1635498,7 +1635066,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1635713,7 +1635281,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1635721,7 +1635289,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1635924,7 +1635492,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1635932,7 +1635500,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1636143,7 +1635711,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1636151,7 +1635719,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1636362,7 +1635930,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1636370,7 +1635938,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1636569,7 +1636137,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1636577,7 +1636145,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1636791,7 +1636359,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1636799,7 +1636367,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1637013,7 +1636581,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1637021,7 +1636589,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1637223,7 +1636791,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1637231,7 +1636799,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1637446,7 +1637014,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1637454,7 +1637022,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1637669,7 +1637237,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1637677,7 +1637245,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1637880,7 +1637448,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1637888,7 +1637456,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1638099,7 +1637667,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1638107,7 +1637675,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1638318,7 +1637886,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1638326,7 +1637894,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1638525,7 +1638093,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1638533,7 +1638101,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1638747,7 +1638315,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1638755,7 +1638323,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1638969,7 +1638537,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1638977,7 +1638545,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1639179,7 +1638747,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1639187,7 +1638755,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1639402,7 +1638970,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1639410,7 +1638978,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1639625,7 +1639193,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1639633,7 +1639201,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1639836,7 +1639404,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1639844,7 +1639412,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1640055,7 +1639623,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1640063,7 +1639631,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1640274,7 +1639842,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 @CacheToDb async getProtocolTokens(): Promise[]> { - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -1640282,7 +1639850,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1640487,14 +1640055,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1640713,14 +1640281,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1640939,14 +1640507,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1641153,14 +1640721,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1641380,14 +1640948,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1641607,14 +1641175,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1641822,14 +1641390,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1642045,14 +1641613,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1642268,14 +1641836,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1642479,14 +1642047,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1642705,14 +1642273,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1642931,14 +1642499,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1643145,14 +1642713,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1643372,14 +1642940,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1643599,14 +1643167,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1643814,14 +1643382,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1644037,14 +1643605,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1644260,14 +1643828,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1644471,14 +1644039,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1644697,14 +1644265,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1644923,14 +1644491,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1645137,14 +1644705,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1645364,14 +1644932,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1645591,14 +1645159,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1645806,14 +1645374,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1646029,14 +1645597,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1646252,14 +1645820,14 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -1646463,7 +1646031,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1646475,7 +1646043,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1646695,7 +1646263,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1646707,7 +1646275,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1646927,7 +1646495,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1646939,7 +1646507,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1647147,7 +1646715,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1647159,7 +1646727,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1647380,7 +1646948,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1647392,7 +1646960,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1647613,7 +1647181,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1647625,7 +1647193,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1647834,7 +1647402,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1647846,7 +1647414,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1648063,7 +1647631,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1648075,7 +1647643,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1648292,7 +1647860,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1648304,7 +1647872,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1648509,7 +1648077,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1648521,7 +1648089,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1648741,7 +1648309,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1648753,7 +1648321,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1648973,7 +1648541,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1648985,7 +1648553,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1649193,7 +1648761,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1649205,7 +1648773,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1649426,7 +1648994,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1649438,7 +1649006,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1649659,7 +1649227,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1649671,7 +1649239,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1649880,7 +1649448,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1649892,7 +1649460,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1650109,7 +1649677,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1650121,7 +1649689,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1650338,7 +1649906,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1650350,7 +1649918,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1650555,7 +1650123,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1650567,7 +1650135,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1650787,7 +1650355,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1650799,7 +1650367,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1651019,7 +1650587,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1651031,7 +1650599,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1651239,7 +1650807,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1651251,7 +1650819,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1651472,7 +1651040,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1651484,7 +1651052,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1651705,7 +1651273,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1651717,7 +1651285,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1651926,7 +1651494,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1651938,7 +1651506,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1652155,7 +1651723,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1652167,7 +1651735,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1652384,7 +1651952,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -1652396,7 +1651964,7 @@ exports[`generateAdapter function snapshots should match snapshot for outcomes 1 '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) diff --git a/packages/adapters-library/src/scripts/adapterBuilder/replacements.ts b/packages/adapters-library/src/scripts/adapterBuilder/replacements.ts index 18e1668b5..83e2d4eb7 100644 --- a/packages/adapters-library/src/scripts/adapterBuilder/replacements.ts +++ b/packages/adapters-library/src/scripts/adapterBuilder/replacements.ts @@ -13,11 +13,9 @@ export const Replacements = { return adapterCode.replace( regex, ` - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') - const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x') - ) + const underlyingToken = await this.helpers.getTokenMetadata('0x') return [ { @@ -32,7 +30,7 @@ export const Replacements = { return adapterCode.replace( regex, ` - const protocolToken = await this.helpers.getTokenMetadata(getAddress('0x')) + const protocolToken = await this.helpers.getTokenMetadata('0x') const underlyingTokens = await Promise.all( [ @@ -40,7 +38,7 @@ export const Replacements = { '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -63,14 +61,14 @@ export const Replacements = { '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) return await Promise.all( protocolTokens.map(async (protocolToken) => { const underlyingToken = await this.helpers.getTokenMetadata( - getAddress('0x'), // Ideally fetched on-chain + '0x', // Ideally fetched on-chain ) return { @@ -92,7 +90,7 @@ export const Replacements = { '0x', // Ideally fetched on-chain from factory contract ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), ) @@ -104,7 +102,7 @@ export const Replacements = { '0x', // Ideally fetched on-chain ].map(async (address) => - this.helpers.getTokenMetadata(getAddress(address)), + this.helpers.getTokenMetadata(address), ), )