@gooddollar/goodprotocol 2.1.0 → 2.1.2

package/test/reserve/GenericDistributionHelper.test.ts

@@ -0,0 +1,315 @@
+import { ethers, upgrades, artifacts } from "hardhat";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
+import { expect } from "chai";
+import { GoodReserveCDai, DistributionBridgeMock, IGoodDollar, GenericDistributionHelperTestHelper } from "../../types";
+import { createDAO, increaseTime } from "../helpers";
+import * as waffle from "ethereum-waffle";
+
+const BN = ethers.BigNumber;
+export const NULL_ADDRESS = ethers.constants.AddressZero;
+export const BLOCK_INTERVAL = 1;
+
+describe("GenericDistributionHelper", () => {
+  let goodReserve: GoodReserveCDai;
+  let goodDollar: IGoodDollar, genericCall, avatar, founder, signers, setDAOAddress, nameService, cDai;
+
+  before(async () => {
+    [founder, ...signers] = await ethers.getSigners();
+    let {
+      controller: ctrl,
+      avatar: av,
+      gd,
+      identity,
+      setDAOAddress: sda,
+      setSchemes,
+      reserve,
+      cdaiAddress,
+      genericCall: gc,
+      nameService: ns
+    } = await loadFixture(createDAO);
+
+    nameService = ns;
+    genericCall = gc;
+    cDai = cdaiAddress;
+    avatar = av;
+    setDAOAddress = sda;
+
+    console.log("deployed dao", {
+      founder: founder.address,
+      gd,
+      identity,
+      avatar
+    });
+
+    goodDollar = (await ethers.getContractAt("IGoodDollar", gd)) as IGoodDollar;
+
+    console.log("deployed contribution, deploying reserve...", {
+      founder: founder.address
+    });
+
+    goodReserve = reserve as GoodReserveCDai;
+  });
+
+  const fixture = async () => {
+    const mpbf = await artifacts.readArtifact("IStaticOracle");
+
+    let oracle = await waffle.deployMockContract(founder, mpbf.abi);
+    oracle.mock.quoteAllAvailablePoolsWithTimePeriod.returns(1e13, []);
+    oracle.mock.prepareAllAvailablePoolsWithTimePeriod.returns([]);
+
+    const distHelper = (await upgrades.deployProxy(
+      await ethers.getContractFactory("GenericDistributionHelperTestHelper"),
+      [
+        nameService.address,
+        oracle.address,
+        ethers.constants.AddressZero,
+        ethers.constants.AddressZero,
+        ethers.constants.AddressZero,
+        {
+          maxFee: "5000000000000000",
+          minBalanceForFees: "10000000000000000",
+          percentageToSellForFee: "5",
+          maxSlippage: "5"
+        }
+      ],
+      { kind: "uups" }
+    )) as GenericDistributionHelperTestHelper;
+
+    //make sure disthelper has enough native token so it doesnt try to swap G$s
+    await founder.sendTransaction({
+      to: distHelper.address,
+      value: ethers.constants.WeiPerEther
+    });
+    const bridge = (await ethers.deployContract("DistributionBridgeMock")) as DistributionBridgeMock;
+
+    const encodedCall = distHelper.interface.encodeFunctionData("setFeeSettings", [
+      {
+        maxFee: "5000000000000000",
+        minBalanceForFees: "10000000000000000",
+        percentageToSellForFee: "5",
+        maxSlippage: "5"
+      }
+    ]);
+
+    await genericCall(distHelper.address, encodedCall, avatar.address, 0);
+    await distHelper.setBridges(bridge.address);
+
+    return { distHelper, bridge, oracle };
+  };
+
+  it("should not allow to add recipient", async () => {
+    const { distHelper } = await loadFixture(fixture);
+
+    const recipient = signers[0];
+
+    await expect(
+      distHelper.addOrUpdateRecipient({
+        bps: 3000,
+        chainId: 42220,
+        addr: recipient.address,
+        transferType: 0
+      })
+    ).to.be.revertedWith(/is missing role 0x0000000000000000000000000000000000000000000000000000000000000000/);
+  });
+
+  it("should allow to add recipient by avatar", async () => {
+    const { distHelper } = await loadFixture(fixture);
+
+    const recipient = signers[0];
+
+    const encodedCall = distHelper.interface.encodeFunctionData("addOrUpdateRecipient", [
+      {
+        bps: 3000,
+        chainId: 42220,
+        addr: recipient.address,
+        transferType: 0
+      }
+    ]);
+
+    await genericCall(distHelper.address, encodedCall, avatar.address, 0);
+    const dr = await distHelper.distributionRecipients(0);
+    expect(dr.addr).to.equal(recipient.address);
+    expect(dr.chainId).to.equal(42220);
+    expect(dr.bps).to.equal(3000);
+    expect(dr.transferType).to.equal(0);
+  });
+
+  it("should allow to update recipient by avatar", async () => {
+    const { distHelper } = await loadFixture(fixture);
+
+    const recipient = signers[0];
+
+    let encodedCall = distHelper.interface.encodeFunctionData("addOrUpdateRecipient", [
+      {
+        bps: 1000,
+        chainId: 4447,
+        addr: recipient.address,
+        transferType: 1
+      }
+    ]);
+
+    await genericCall(distHelper.address, encodedCall, avatar.address, 0);
+
+    encodedCall = distHelper.interface.encodeFunctionData("addOrUpdateRecipient", [
+      {
+        bps: 1500,
+        chainId: 45,
+        addr: recipient.address,
+        transferType: 0
+      }
+    ]);
+
+    await genericCall(distHelper.address, encodedCall, avatar.address, 0);
+
+    const updEvents = await distHelper.queryFilter(distHelper.filters.RecipientUpdated());
+    const addEvents = await distHelper.queryFilter(distHelper.filters.RecipientAdded());
+
+    const dr = await distHelper.distributionRecipients(0);
+    expect(dr.addr).to.equal(recipient.address);
+    expect(dr.chainId).to.equal(45);
+    expect(dr.bps).to.equal(1500);
+    expect(dr.transferType).to.equal(0);
+  });
+
+  it("should distribute via layerzero bridge", async () => {
+    const { distHelper, bridge } = await loadFixture(fixture);
+
+    const recipient = signers[0];
+
+    let encodedCall = distHelper.interface.encodeFunctionData("addOrUpdateRecipient", [
+      {
+        bps: 2000,
+        chainId: 42220,
+        addr: recipient.address,
+        transferType: 0
+      }
+    ]);
+
+    await genericCall(distHelper.address, encodedCall, avatar.address, 0);
+
+    await goodDollar.mint(distHelper.address, "100000000000");
+    await founder.sendTransaction({
+      to: distHelper.address,
+      value: ethers.constants.WeiPerEther
+    });
+    await distHelper.onDistribution("100000000000");
+    expect(await goodDollar.allowance(distHelper.address, bridge.address)).to.equal((100000000000 * 2000) / 10000);
+
+    const events = await bridge.queryFilter(bridge.filters.BridgeLz());
+    expect(events[0].args.recipient).to.equal(recipient.address);
+    expect(events[0].args.amount).to.equal((100000000000 * 2000) / 10000);
+    expect(events[0].args.chainId).to.equal(42220);
+    expect(events[0].args.fee).to.equal(5e14);
+  });
+
+  it("should distribute via transferAndCall", async () => {
+    const { distHelper, bridge } = await loadFixture(fixture);
+
+    const recipient = signers[0];
+
+    let encodedCall = distHelper.interface.encodeFunctionData("addOrUpdateRecipient", [
+      {
+        bps: 2555,
+        chainId: 4447,
+        addr: signers[0].address,
+        transferType: 2
+      }
+    ]);
+
+    await genericCall(distHelper.address, encodedCall, avatar.address, 0);
+
+    await goodDollar.mint(distHelper.address, "100000000000");
+    await distHelper.onDistribution("100000000000");
+    expect(await goodDollar.balanceOf(signers[0].address)).to.equal((100000000000 * 2555) / 10000);
+  });
+
+  it("should distribute to multiple recipients", async () => {
+    const { distHelper, bridge } = await loadFixture(fixture);
+
+    const recipient = signers[0];
+
+    let encodedCall = distHelper.interface.encodeFunctionData("addOrUpdateRecipient", [
+      {
+        bps: 2555,
+        chainId: 4447,
+        addr: signers[0].address,
+        transferType: 1
+      }
+    ]);
+
+    await genericCall(distHelper.address, encodedCall, avatar.address, 0);
+
+    encodedCall = distHelper.interface.encodeFunctionData("addOrUpdateRecipient", [
+      {
+        bps: 1000,
+        chainId: 4447,
+        addr: signers[1].address,
+        transferType: 1
+      }
+    ]);
+
+    await genericCall(distHelper.address, encodedCall, avatar.address, 0);
+
+    encodedCall = distHelper.interface.encodeFunctionData("addOrUpdateRecipient", [
+      {
+        bps: 5,
+        chainId: 4447,
+        addr: signers[2].address,
+        transferType: 2
+      }
+    ]);
+
+    await genericCall(distHelper.address, encodedCall, avatar.address, 0);
+
+    await goodDollar.mint(distHelper.address, "100000000000");
+    await distHelper.onDistribution("100000000000");
+    expect(await goodDollar.balanceOf(signers[0].address)).to.equal((100000000000 * 2555) / 10000);
+    expect(await goodDollar.balanceOf(signers[1].address)).to.equal((100000000000 * 1000) / 10000);
+    expect(await goodDollar.balanceOf(signers[2].address)).to.equal((100000000000 * 5) / 10000);
+  });
+
+  it("should emit distribution event for multiple recipients", async () => {
+    const { distHelper, bridge } = await loadFixture(fixture);
+
+    let encodedCall = distHelper.interface.encodeFunctionData("addOrUpdateRecipient", [
+      {
+        bps: 2555,
+        chainId: 122,
+        addr: signers[0].address,
+        transferType: 0
+      }
+    ]);
+
+    await genericCall(distHelper.address, encodedCall, avatar.address, 0);
+
+    encodedCall = distHelper.interface.encodeFunctionData("addOrUpdateRecipient", [
+      {
+        bps: 1000,
+        chainId: 4447,
+        addr: signers[1].address,
+        transferType: 1
+      }
+    ]);
+
+    await genericCall(distHelper.address, encodedCall, avatar.address, 0);
+
+    encodedCall = distHelper.interface.encodeFunctionData("addOrUpdateRecipient", [
+      {
+        bps: 5,
+        chainId: 4447,
+        addr: signers[2].address,
+        transferType: 2
+      }
+    ]);
+
+    await genericCall(distHelper.address, encodedCall, avatar.address, 0);
+
+    await goodDollar.mint(distHelper.address, "100000000000");
+    await distHelper.onDistribution("100000000000");
+
+    const DistributionEvents = await distHelper.queryFilter(distHelper.filters.Distribution());
+    expect(DistributionEvents[0].args.distributionRecipients[0].addr).eq(signers[0].address);
+    expect(DistributionEvents[0].args.distributionRecipients[1].addr).eq(signers[1].address);
+    expect(DistributionEvents[0].args.distributionRecipients[2].addr).eq(signers[2].address);
+  });
+});

package/test/ubi/UBISchemeCycle.test.ts

@@ -13,19 +13,10 @@ const ONE_DAY = 86400;
 describe("UBIScheme cycle", () => {
   let goodDollar, firstClaimPool;
   let reputation;
-  let root,
-    acct,
-    claimer1,
-    claimer2,
-    claimer3,
-    signers,
-    nameService,
-    genericCall,
-    ubiScheme: UBIScheme;
+  let root, acct, claimer1, claimer2, claimer3, signers, nameService, genericCall, ubiScheme: UBIScheme;
 
   before(async () => {
-    [root, acct, claimer1, claimer2, claimer3, ...signers] =
-      await ethers.getSigners();
+    [root, acct, claimer1, claimer2, claimer3, ...signers] = await ethers.getSigners();
 
     const deployedDAO = await loadFixture(createDAO);
     let {
@@ -64,9 +55,7 @@ describe("UBIScheme cycle", () => {
 
   it("should be able to change cycleLength if avatar", async () => {
     // initializing the ubi
-    let encodedCall = ubiScheme.interface.encodeFunctionData("setCycleLength", [
-      8
-    ]);
+    let encodedCall = ubiScheme.interface.encodeFunctionData("setCycleLength", [8]);
     await genericCall(ubiScheme.address, encodedCall);
     expect(await ubiScheme.cycleLength()).to.be.equal(8);
   });
@@ -81,10 +70,7 @@ describe("UBIScheme cycle", () => {
 
   it("should set ubischeme", async () => {
     // initializing the ubi
-    let encodedCall = firstClaimPool.interface.encodeFunctionData(
-      "setUBIScheme",
-      [ubiScheme.address]
-    );
+    let encodedCall = firstClaimPool.interface.encodeFunctionData("setUBIScheme", [ubiScheme.address]);
 
     await genericCall(firstClaimPool.address, encodedCall);
     // await firstClaimPool.start();
@@ -99,9 +85,7 @@ describe("UBIScheme cycle", () => {
     let currentCycle = await ubiScheme.currentCycleLength();
     let dailyAmount = await ubiScheme.dailyUbi();
     expect(currentCycle.toNumber()).to.be.gt(0);
-    const cycleEvent = transaction.events.find(
-      e => e.event === "UBICycleCalculated"
-    );
+    const cycleEvent = transaction.events.find(e => e.event === "UBICycleCalculated");
     console.log({
       dailyAmount: dailyAmount.toString(),
       event: cycleEvent.args
@@ -117,50 +101,40 @@ describe("UBIScheme cycle", () => {
     await ubiScheme.connect(claimer2).claim();
     increaseTime(ONE_DAY);
     let transaction = await ubiScheme.connect(claimer2).claim();
-    expect(
-      await goodDollar.balanceOf(claimer2.address).then(_ => _.toNumber())
-    ).to.be.equal(125 + (await ubiScheme.dailyUbi().then(_ => _.toNumber()))); //first day 125 , second claim 125000 wei daily pool divided by 1000 active users = 125
-    expect(
-      await ubiScheme.dailyCyclePool().then(_ => _.toNumber())
-    ).to.be.equal(125000);
-    expect(
-      await ubiScheme.currentDayInCycle().then(_ => _.toNumber())
-    ).to.be.equal(1); //1 day passed
+    expect(await goodDollar.balanceOf(claimer2.address).then(_ => _.toNumber())).to.be.equal(
+      125 + (await ubiScheme.dailyUbi().then(_ => _.toNumber()))
+    ); //first day 125 , second claim 125000 wei daily pool divided by 1000 active users = 125
+    expect(await ubiScheme.dailyCyclePool().then(_ => _.toNumber())).to.be.equal(125000);
+    expect(await ubiScheme.currentDayInCycle().then(_ => _.toNumber())).to.be.equal(1); //1 day passed
   });
 
   it("should calculate next cycle even if day passed without claims(setDay)", async () => {
     increaseTime(ONE_DAY * 9);
-    expect(
-      await ubiScheme.currentDayInCycle().then(_ => _.toNumber())
-    ).to.be.equal(10); //10 days passed total
-
+    expect(await ubiScheme.currentDayInCycle().then(_ => _.toNumber())).to.be.equal(10); //10 days passed total
+
+    const claimerBalanceBefore = await goodDollar.balanceOf(claimer1.address);
+    const minActiveUsers = await ubiScheme.minActiveUsers();
+    let dailyClaimAmount = (await ubiScheme.dailyCyclePool()).div(minActiveUsers); //initialy we have by default min 1000 active users
+    const estimatedUbi = await ubiScheme.estimateNextDailyUBI();
+    let totalClaimed = 0;
+    const currentDay = (await ubiScheme.currentDay()).toNumber();
+    for (let i = currentDay; i >= 0; i--) {
+      totalClaimed += (await ubiScheme.claimDay(i)).claimAmount.toNumber();
+    }
     let transaction = await (await ubiScheme.connect(claimer1).claim()).wait(); //claims in new ubi cycle
-    let dailyClaimAmount = (await ubiScheme.dailyCyclePool()).div(1000); //initialy we have by default min 1000 active users
-
-    expect(await goodDollar.balanceOf(claimer1.address)).to.be.equal(
-      dailyClaimAmount.add(125)
-    ); //intial 10 from first claim pool + daily
-    const cycleEvent = transaction.events.find(
-      e => e.event === "UBICycleCalculated"
-    );
+    const cycleEvent = transaction.events.find(e => e.event === "UBICycleCalculated");
 
+    expect(await goodDollar.balanceOf(claimer1.address)).to.be.equal(claimerBalanceBefore.add(dailyClaimAmount)); //intial 10 from first claim pool + daily
+    expect(dailyClaimAmount).eq(estimatedUbi);
     expect(cycleEvent).to.be.not.empty;
-
-    expect(
-      await ubiScheme.currentDayInCycle().then(_ => _.toNumber())
-    ).to.be.equal(0); //new cycle started
+    expect(await ubiScheme.currentDayInCycle().then(_ => _.toNumber())).to.be.equal(0); //new cycle started
     //intial balance on cycle start 1000000 - 375(3 user that claimed in previous tests) = 99625, divide by cycle length (8) = 124953
-    expect(cycleEvent.args.dailyUBIPool).to.be.equal(
-      (BigInt(1000000) - BigInt(375)) / BigInt(8)
-    );
+    expect(cycleEvent.args.dailyUBIPool).to.be.equal((BigInt(1000000) - BigInt(totalClaimed)) / BigInt(8));
   });
 
   it("should calculate cycle early if we can increase current daily pool", async () => {
     //increase ubi pool balance
-    let encoded = goodDollar.interface.encodeFunctionData("mint", [
-      ubiScheme.address,
-      400000
-    ]);
+    let encoded = goodDollar.interface.encodeFunctionData("mint", [ubiScheme.address, 400000]);
     await genericCall(goodDollar.address, encoded);
     let balance = await goodDollar.balanceOf(ubiScheme.address);
 
@@ -173,9 +147,7 @@ describe("UBIScheme cycle", () => {
     const estimated = await ubiScheme.estimateNextDailyUBI();
     await increaseTime(ONE_DAY); //make sure
     let transaction = await (await ubiScheme.connect(claimer1).claim()).wait();
-    const cycleEvent = transaction.events.find(
-      e => e.event === "UBICycleCalculated"
-    );
+    const cycleEvent = transaction.events.find(e => e.event === "UBICycleCalculated");
     const dailyUBI = await ubiScheme.dailyUbi();
     expect(dailyUBI).to.eq(estimated); //the estimated before actual calculation should be correct, ie equal to actual dailyUBI calculated after first claim.
     expect(cycleEvent).to.be.not.empty;
@@ -187,10 +159,7 @@ describe("UBIScheme cycle", () => {
 
   it("should not calculate cycle early if not possible to increase daily ubi pool", async () => {
     //increase ubi pool balance
-    let encoded = goodDollar.interface.encodeFunctionData("mint", [
-      ubiScheme.address,
-      100
-    ]);
+    let encoded = goodDollar.interface.encodeFunctionData("mint", [ubiScheme.address, 100]);
     await genericCall(goodDollar.address, encoded);
     let balance = await goodDollar.balanceOf(ubiScheme.address);
     const curCycleLen = await ubiScheme.cycleLength();
@@ -200,9 +169,7 @@ describe("UBIScheme cycle", () => {
 
     await increaseTime(ONE_DAY); //make sure
     let transaction = await (await ubiScheme.connect(claimer1).claim()).wait();
-    const cycleEvent = transaction.events.find(
-      e => e.event === "UBICycleCalculated"
-    );
+    const cycleEvent = transaction.events.find(e => e.event === "UBICycleCalculated");
     expect(cycleEvent).to.be.undefined;
   });
 });

package/types/contracts/IUniswapV3.sol/IUniswapV3Pool.ts

@@ -24,6 +24,7 @@ import type {
 
 export interface IUniswapV3PoolInterface extends utils.Interface {
   functions: {
+    "fee()": FunctionFragment;
     "initialize(uint160)": FunctionFragment;
     "slot0()": FunctionFragment;
     "token0()": FunctionFragment;
@@ -31,9 +32,10 @@ export interface IUniswapV3PoolInterface extends utils.Interface {
   };
 
   getFunction(
-    nameOrSignatureOrTopic: "initialize" | "slot0" | "token0" | "token1"
+    nameOrSignatureOrTopic: "fee" | "initialize" | "slot0" | "token0" | "token1"
   ): FunctionFragment;
 
+  encodeFunctionData(functionFragment: "fee", values?: undefined): string;
   encodeFunctionData(
     functionFragment: "initialize",
     values: [BigNumberish]
@@ -42,6 +44,7 @@ export interface IUniswapV3PoolInterface extends utils.Interface {
   encodeFunctionData(functionFragment: "token0", values?: undefined): string;
   encodeFunctionData(functionFragment: "token1", values?: undefined): string;
 
+  decodeFunctionResult(functionFragment: "fee", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "slot0", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "token0", data: BytesLike): Result;
@@ -77,6 +80,8 @@ export interface IUniswapV3Pool extends BaseContract {
   removeListener: OnEvent<this>;
 
   functions: {
+    fee(overrides?: CallOverrides): Promise<[number]>;
+
     initialize(
       sqrtPriceX96: BigNumberish,
       overrides?: Overrides & { from?: string }
@@ -101,6 +106,8 @@ export interface IUniswapV3Pool extends BaseContract {
     token1(overrides?: CallOverrides): Promise<[string]>;
   };
 
+  fee(overrides?: CallOverrides): Promise<number>;
+
   initialize(
     sqrtPriceX96: BigNumberish,
     overrides?: Overrides & { from?: string }
@@ -125,6 +132,8 @@ export interface IUniswapV3Pool extends BaseContract {
   token1(overrides?: CallOverrides): Promise<string>;
 
   callStatic: {
+    fee(overrides?: CallOverrides): Promise<number>;
+
     initialize(
       sqrtPriceX96: BigNumberish,
       overrides?: CallOverrides
@@ -152,6 +161,8 @@ export interface IUniswapV3Pool extends BaseContract {
   filters: {};
 
   estimateGas: {
+    fee(overrides?: CallOverrides): Promise<BigNumber>;
+
     initialize(
       sqrtPriceX96: BigNumberish,
       overrides?: Overrides & { from?: string }
@@ -165,6 +176,8 @@ export interface IUniswapV3Pool extends BaseContract {
   };
 
   populateTransaction: {
+    fee(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     initialize(
       sqrtPriceX96: BigNumberish,
       overrides?: Overrides & { from?: string }

package/types/contracts/MentoInterfaces.sol/IBancorExchangeProvider.ts

@@ -55,6 +55,7 @@ export declare namespace IBancorExchangeProvider {
 
 export interface IBancorExchangeProviderInterface extends utils.Interface {
   functions: {
+    "AVATAR()": FunctionFragment;
     "createExchange((address,address,uint256,uint256,uint32,uint32))": FunctionFragment;
     "currentPrice(bytes32)": FunctionFragment;
     "destroyExchange(bytes32,uint256)": FunctionFragment;
@@ -65,6 +66,7 @@ export interface IBancorExchangeProviderInterface extends utils.Interface {
 
   getFunction(
     nameOrSignatureOrTopic:
+      | "AVATAR"
       | "createExchange"
       | "currentPrice"
       | "destroyExchange"
@@ -73,6 +75,7 @@ export interface IBancorExchangeProviderInterface extends utils.Interface {
       | "setExitContribution"
   ): FunctionFragment;
 
+  encodeFunctionData(functionFragment: "AVATAR", values?: undefined): string;
   encodeFunctionData(
     functionFragment: "createExchange",
     values: [IBancorExchangeProvider.PoolExchangeStruct]
@@ -98,6 +101,7 @@ export interface IBancorExchangeProviderInterface extends utils.Interface {
     values: [BytesLike, BigNumberish]
   ): string;
 
+  decodeFunctionResult(functionFragment: "AVATAR", data: BytesLike): Result;
   decodeFunctionResult(
     functionFragment: "createExchange",
     data: BytesLike
@@ -219,6 +223,8 @@ export interface IBancorExchangeProvider extends BaseContract {
   removeListener: OnEvent<this>;
 
   functions: {
+    AVATAR(overrides?: CallOverrides): Promise<[string]>;
+
     createExchange(
       exchange: IBancorExchangeProvider.PoolExchangeStruct,
       overrides?: Overrides & { from?: string }
@@ -255,6 +261,8 @@ export interface IBancorExchangeProvider extends BaseContract {
     ): Promise<ContractTransaction>;
   };
 
+  AVATAR(overrides?: CallOverrides): Promise<string>;
+
   createExchange(
     exchange: IBancorExchangeProvider.PoolExchangeStruct,
     overrides?: Overrides & { from?: string }
@@ -285,6 +293,8 @@ export interface IBancorExchangeProvider extends BaseContract {
   ): Promise<ContractTransaction>;
 
   callStatic: {
+    AVATAR(overrides?: CallOverrides): Promise<string>;
+
     createExchange(
       exchange: IBancorExchangeProvider.PoolExchangeStruct,
       overrides?: CallOverrides
@@ -359,6 +369,8 @@ export interface IBancorExchangeProvider extends BaseContract {
   };
 
   estimateGas: {
+    AVATAR(overrides?: CallOverrides): Promise<BigNumber>;
+
     createExchange(
       exchange: IBancorExchangeProvider.PoolExchangeStruct,
       overrides?: Overrides & { from?: string }
@@ -390,6 +402,8 @@ export interface IBancorExchangeProvider extends BaseContract {
   };
 
   populateTransaction: {
+    AVATAR(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     createExchange(
       exchange: IBancorExchangeProvider.PoolExchangeStruct,
       overrides?: Overrides & { from?: string }