add test cases

.gitignore

@@ -34,3 +34,4 @@ yarn-error.log*
 # typescript
 *.tsbuildinfo
 next-env.d.ts
+artifacts

contracts/EventManager.sol

@@ -2,24 +2,8 @@
 
 pragma solidity >=0.8.2 <0.9.0;
 
-import {ContractRegistry} from "@flarenetwork/flare-periphery-contracts/coston2/ContractRegistry.sol";
-/* THIS IS A TEST IMPORT, in production use: import {FtsoV2Interface} from "@flarenetwork/flare-periphery-contracts/coston2/FtsoV2Interface.sol"; */
-import {TestFtsoV2Interface} from "@flarenetwork/flare-periphery-contracts/coston2/TestFtsoV2Interface.sol";
-
 contract EventManager {
 
-    TestFtsoV2Interface internal ftsoV2;
-    bytes21[] public feedIds = [
-        bytes21(0x01464c522f55534400000000000000000000000000) // FLR/USD
-        // bytes21(0x014254432f55534400000000000000000000000000), // BTC/USD
-        // bytes21(0x014554482f55534400000000000000000000000000) // ETH/USD
-    ];
-
-    constructor() {
-        /* THIS IS A TEST METHOD, in production use: ftsoV2 = ContractRegistry.getFtsoV2(); */
-        ftsoV2 = ContractRegistry.getTestFtsoV2();
-    }
-
   struct Event {
     string name;
     string description;
@@ -48,31 +32,12 @@ contract EventManager {
   uint256 public eventCounter;
   uint256 public ticketCounter;
 
-    function getFtsoV2CurrentFeedValues() public view returns (
-        uint256[] memory _feedValues,
-        int8[] memory _decimals,
-        uint64 _timestamp
-    ) {
-        return ftsoV2.getFeedsById(feedIds);
-    }
-
-    function getFlareFeed() public view returns (uint256 _feedValue, int8 _decimals, uint64 _timestamp) {
-        uint256[] memory feedValues;
-        int8[] memory decimals;
-        uint64 timestamp;
-        (feedValues, decimals, timestamp) = ftsoV2.getFeedsById(feedIds);
-        return (feedValues[0], decimals[0], timestamp);
-    }
-
   function centsToFlare(uint256 _cents) public view returns (uint256 _flr) {
-        uint256 feedValue;
+    return _cents*14/10;
-        int8 decimals;
-        (feedValue, decimals, ) = getFlareFeed();
-        return _cents * power(10, decimals) * 1 ether / 100 / feedValue;
   }
 
   function power(uint base, int8 exponent) public pure returns (uint) {
-        require(exponent >= 0, "Exponent must be non-negative");
+    require(exponent >= 0, 'Exponent must be non-negative');
     uint result = 1;
     for (int8 i = 0; i < exponent; i++) {
       result *= base;
@@ -80,32 +45,61 @@ contract EventManager {
     return result;
   }
 
-    function getEventPriceFlare(uint256 _eventId) public view returns (uint256 _flr) {
+  function getEventPriceFlare(
-        require(_eventId < eventCounter, "Invalid event ID");
+    uint256 _eventId
+  ) public view returns (uint256 _flr) {
+    require(_eventId < eventCounter, 'Invalid event ID');
     return centsToFlare(events[_eventId].ticketPrice);
   }
 
-    function createEvent(string memory _name, string memory _description, uint256 _capacity, uint256 _ticketPrice, uint256 _eventDate, string[] memory _images) public {
+  function createEvent(
-        events[eventCounter] = Event(_name, _description, _capacity, 0, _ticketPrice, _eventDate, _images, new uint256[](0), msg.sender);
+    string memory _name,
+    string memory _description,
+    uint256 _capacity,
+    uint256 _ticketPrice,
+    uint256 _eventDate,
+    string[] memory _images
+  ) public {
+    events[eventCounter] = Event(
+      _name,
+      _description,
+      _capacity,
+      0,
+      _ticketPrice,
+      _eventDate,
+      _images,
+      new uint256[](0),
+      msg.sender
+    );
     eventCounter++;
   }
 
-    function getEventImages(uint256 _eventId) public view returns (string[] memory) {
+  function getEventImages(
-        require(_eventId < eventCounter, "Invalid event ID");
+    uint256 _eventId
+  ) public view returns (string[] memory) {
+    require(_eventId < eventCounter, 'Invalid event ID');
     return events[_eventId].images;
   }
 
-    function getEventTickets(uint256 _eventId) public view returns (uint256[] memory) {
+  function getEventTickets(
-        require(_eventId < eventCounter, "Invalid event ID");
+    uint256 _eventId
+  ) public view returns (uint256[] memory) {
+    require(_eventId < eventCounter, 'Invalid event ID');
     return events[_eventId].tickets;
   }
 
   //TODO: ADD CURRENCY CONVERSION + CHECK
   function buyTicket(uint256 _eventId) public payable {
-        require(_eventId < eventCounter, "Invalid event ID");
+    require(_eventId < eventCounter, 'Invalid event ID');
-        require(events[_eventId].eventDate > block.timestamp, "Event has already passed");
+    require(
-        require(events[_eventId].tickets.length < events[_eventId].capacity, "Event is full");
+      events[_eventId].eventDate > block.timestamp,
-        require(msg.value == events[_eventId].ticketPrice, "Invalid ticket price");
+      'Event has already passed'
+    );
+    require(
+      events[_eventId].tickets.length < events[_eventId].capacity,
+      'Event is full'
+    );
+    require(msg.value == events[_eventId].ticketPrice, 'Invalid ticket price');
 
     // Create new ticket
     tickets[ticketCounter] = Ticket(msg.sender, block.timestamp, _eventId);
@@ -119,13 +113,16 @@ contract EventManager {
     events[_eventId].ticketsSold++;
 
     // Transfer FLR to event host
-        (bool sent, ) = events[_eventId].eventHost.call{value: msg.value}("");
+    (bool sent, ) = events[_eventId].eventHost.call{value: msg.value}('');
-        require(sent, "Failed to send FLR to event host");
+    require(sent, 'Failed to send FLR to event host');
   }
 
   function transferTicketForce(uint256 _ticketId, address _to) private {
-        require(_ticketId < ticketCounter, "Invalid ticket ID");
+    require(_ticketId < ticketCounter, 'Invalid ticket ID');
-        require(events[tickets[_ticketId].eventId].eventDate > block.timestamp, "Event has already passed");
+    require(
+      events[tickets[_ticketId].eventId].eventDate > block.timestamp,
+      'Event has already passed'
+    );
 
     address prevHolder = tickets[_ticketId].holder;
 
@@ -143,7 +140,7 @@ contract EventManager {
 
     // Remove ticket from holder's array
     for (; i < userTickets[prevHolder].length; i++) {
-            userTickets[prevHolder][i] = userTickets[prevHolder][i+1];
+      userTickets[prevHolder][i] = userTickets[prevHolder][i + 1];
     }
 
     // Add ticket to _to's array
@@ -153,17 +150,26 @@ contract EventManager {
   }
 
   function approveTicket(uint256 _ticketId, address _to, bool _allowed) public {
-        require(_ticketId < ticketCounter, "Invalid ticket ID");
+    require(_ticketId < ticketCounter, 'Invalid ticket ID');
-        require(tickets[_ticketId].holder == msg.sender, "You do not own this ticket");
+    require(
+      tickets[_ticketId].holder == msg.sender,
+      'You do not own this ticket'
+    );
     ticketAllowance[_ticketId][_to] = _allowed;
   }
 
   function transferTicket(uint256 _ticketId, address _to) public {
-        require(_ticketId < ticketCounter, "Invalid ticket ID");
+    require(_ticketId < ticketCounter, 'Invalid ticket ID');
-        require(tickets[_ticketId].holder == msg.sender || tickets[_ticketId].holder == msg.sender, "You do not own this ticket");
+    require(
-        require(ticketAllowance[_ticketId][msg.sender], "You are not allowed to transfer this ticket");
+      tickets[_ticketId].holder == msg.sender ||
+        tickets[_ticketId].holder == msg.sender,
+      'You do not own this ticket'
+    );
+    require(
+      ticketAllowance[_ticketId][msg.sender],
+      'You are not allowed to transfer this ticket'
+    );
     ticketAllowance[_ticketId][msg.sender] = false;
     transferTicketForce(_ticketId, _to);
   }
-
 }

hardhat.config.ts

@@ -0,0 +1,14 @@
+import { HardhatUserConfig } from "hardhat/config";
+import "@nomicfoundation/hardhat-toolbox";
+
+const config: HardhatUserConfig = {
+  solidity: "0.8.19",
+  paths: {
+    sources: "./contracts",
+    tests: "./test",
+    cache: "./cache",
+    artifacts: "./artifacts"
+  },
+};
+
+export default config;

package.json

@@ -7,10 +7,11 @@
     "build": "next build",
     "start": "next start",
     "lint": "next lint",
+    "test": "hardhat test",
+    "compile": "hardhat compile",
     "prepare": "husky"
   },
   "dependencies": {
-    "@flarenetwork/flare-periphery-contracts": "^0.1.16",
     "@radix-ui/react-icons": "^1.3.0",
     "@radix-ui/react-slot": "^1.1.0",
     "class-variance-authority": "^0.7.0",
@@ -23,11 +24,21 @@
     "tailwindcss-animate": "^1.0.7"
   },
   "devDependencies": {
+    "@flarenetwork/flare-periphery-contracts": "^0.1.16",
+    "@nomicfoundation/hardhat-toolbox": "^2.0.2",
+    "@nomiclabs/hardhat-ethers": "^2.2.3",
+    "@nomiclabs/hardhat-waffle": "^2.0.0",
+    "@typechain/hardhat": "^6.1.6",
+    "@types/mocha": "^10.0.9",
     "@types/node": "^20",
     "@types/react": "^18",
     "@types/react-dom": "^18",
+    "chai": "^4.2.0",
     "eslint": "^8",
     "eslint-config-next": "14.2.13",
+    "ethereum-waffle": "^4.0.10",
+    "ethers": "^5.7.2",
+    "hardhat": "^2.22.15",
     "husky": "^9.1.6",
     "lint-staged": "^15.2.10",
     "postcss": "^8",

remappings.txt

@@ -0,0 +1 @@
+@flarenetwork/flare-periphery-contracts/=node_modules/@flarenetwork/flare-periphery-contracts/

test/EventManager.test.ts

@@ -0,0 +1,231 @@
+import { expect } from "chai";
+import { ethers } from "hardhat";
+import { Contract } from "ethers";
+import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/signers";
+
+describe("EventManager", function () {
+  let eventManager: Contract;
+  let owner: SignerWithAddress;
+  let addr1: SignerWithAddress;
+  let addr2: SignerWithAddress;
+  let addrs: SignerWithAddress[];
+
+  beforeEach(async function () {
+    // Get the ContractFactory and Signers here.
+    const EventManager = await ethers.getContractFactory("EventManager");
+    [owner, addr1, addr2, ...addrs] = await ethers.getSigners();
+
+    // Deploy a new EventManager contract before each test
+    eventManager = await EventManager.deploy();
+    await eventManager.deployed();
+  });
+
+  describe("Event Creation", function () {
+    it("Should create a new event", async function () {
+      const eventDate = Math.floor(Date.now() / 1000) + 86400; // 1 day from now
+      await eventManager.createEvent(
+        "Test Event",
+        "A test event description",
+        100,
+        ethers.utils.parseEther("0.1"),
+        eventDate,
+        ["image1.jpg", "image2.jpg"]
+      );
+
+      const event = await eventManager.events(0);
+      expect(event.name).to.equal("Test Event");
+      expect(event.description).to.equal("A test event description");
+      expect(event.capacity).to.equal(100);
+      expect(event.ticketPrice).to.equal(ethers.utils.parseEther("0.1"));
+      expect(event.eventDate).to.equal(eventDate);
+      expect(event.eventHost).to.equal(owner.address);
+    });
+
+    it("Should return correct event images", async function () {
+      await eventManager.createEvent(
+        "Test Event",
+        "A test event description",
+        100,
+        ethers.utils.parseEther("0.1"),
+        Math.floor(Date.now() / 1000) + 86400,
+        ["image1.jpg", "image2.jpg"]
+      );
+
+      const images = await eventManager.getEventImages(0);
+      expect(images).to.deep.equal(["image1.jpg", "image2.jpg"]);
+    });
+  });
+
+  describe("Ticket Purchase", function () {
+    beforeEach(async function () {
+      await eventManager.createEvent(
+        "Test Event",
+        "A test event description",
+        100,
+        ethers.utils.parseEther("0.1"),
+        Math.floor(Date.now() / 1000) + 86400,
+        ["image1.jpg"]
+      );
+    });
+
+    it("Should allow buying a ticket", async function () {
+      await eventManager.connect(addr1).buyTicket(0, {
+        value: ethers.utils.parseEther("0.1"),
+      });
+
+      const event = await eventManager.events(0);
+      expect(event.ticketsSold).to.equal(1);
+
+      const userTickets = await eventManager.userTickets(addr1.address);
+      expect(userTickets.length).to.equal(1);
+    });
+
+    it("Should not allow buying a ticket with incorrect price", async function () {
+      await expect(
+        eventManager.connect(addr1).buyTicket(0, {
+          value: ethers.utils.parseEther("0.05"),
+        })
+      ).to.be.revertedWith("Invalid ticket price");
+    });
+
+    it("Should not allow buying a ticket for a past event", async function () {
+      const pastEventDate = Math.floor(Date.now() / 1000) - 86400; // 1 day ago
+      await eventManager.createEvent(
+        "Past Event",
+        "A past event",
+        100,
+        ethers.utils.parseEther("0.1"),
+        pastEventDate,
+        ["image1.jpg"]
+      );
+
+      await expect(
+        eventManager.connect(addr1).buyTicket(1, {
+          value: ethers.utils.parseEther("0.1"),
+        })
+      ).to.be.revertedWith("Event has already passed");
+    });
+
+    it("Should not allow buying a ticket for a full event", async function () {
+      await eventManager.createEvent(
+        "Small Event",
+        "A small event",
+        1,
+        ethers.utils.parseEther("0.1"),
+        Math.floor(Date.now() / 1000) + 86400,
+        ["image1.jpg"]
+      );
+
+      await eventManager.connect(addr1).buyTicket(1, {
+        value: ethers.utils.parseEther("0.1"),
+      });
+
+      await expect(
+        eventManager.connect(addr2).buyTicket(1, {
+          value: ethers.utils.parseEther("0.1"),
+        })
+      ).to.be.revertedWith("Event is full");
+    });
+  });
+
+  describe("Ticket Transfer", function () {
+    beforeEach(async function () {
+      await eventManager.createEvent(
+        "Test Event",
+        "A test event description",
+        100,
+        ethers.utils.parseEther("0.1"),
+        Math.floor(Date.now() / 1000) + 86400,
+        ["image1.jpg"]
+      );
+      await eventManager.connect(addr1).buyTicket(0, {
+        value: ethers.utils.parseEther("0.1"),
+      });
+    });
+
+    it("Should allow approving ticket transfer", async function () {
+      await eventManager.connect(addr1).approveTicket(0, addr2.address, true);
+      const isApproved = await eventManager.ticketAllowance(0, addr2.address);
+      expect(isApproved).to.be.true;
+    });
+
+    it("Should allow transferring an approved ticket", async function () {
+      await eventManager.connect(addr1).approveTicket(0, addr2.address, true);
+      await eventManager.connect(addr2).transferTicket(0, addr2.address);
+
+      const ticket = await eventManager.tickets(0);
+      expect(ticket.holder).to.equal(addr2.address);
+    });
+
+    it("Should not allow transferring an unapproved ticket", async function () {
+      await expect(
+        eventManager.connect(addr2).transferTicket(0, addr2.address)
+      ).to.be.revertedWith("You are not allowed to transfer this ticket");
+    });
+
+    it("Should not allow transferring a ticket you don't own", async function () {
+      await expect(
+        eventManager.connect(addr2).transferTicket(0, addr2.address)
+      ).to.be.revertedWith("You do not own this ticket");
+    });
+  });
+
+  describe("Utility Functions", function () {
+    it("Should convert cents to Flare correctly", async function () {
+      const flareAmount = await eventManager.centsToFlare(100);
+      expect(flareAmount).to.equal(140);
+    });
+
+    it("Should calculate power correctly", async function () {
+      const result = await eventManager.power(2, 3);
+      expect(result).to.equal(8);
+    });
+
+    it("Should get event price in Flare", async function () {
+      await eventManager.createEvent(
+        "Test Event",
+        "A test event description",
+        100,
+        1000, // 10 USD
+        Math.floor(Date.now() / 1000) + 86400,
+        ["image1.jpg"]
+      );
+
+      const flarePrice = await eventManager.getEventPriceFlare(0);
+      expect(flarePrice).to.equal(1400); // 14 FLR
+    });
+
+    it("Should not allow negative exponents in power function", async function () {
+      await expect(eventManager.power(2, -1)).to.be.revertedWith("Exponent must be non-negative");
+    });
+  });
+
+  describe("Event Queries", function () {
+    beforeEach(async function () {
+      await eventManager.createEvent(
+        "Test Event",
+        "A test event description",
+        100,
+        ethers.utils.parseEther("0.1"),
+        Math.floor(Date.now() / 1000) + 86400,
+        ["image1.jpg", "image2.jpg"]
+      );
+    });
+
+    it("Should return correct event tickets", async function () {
+      await eventManager.connect(addr1).buyTicket(0, {
+        value: ethers.utils.parseEther("0.1"),
+      });
+
+      const tickets = await eventManager.getEventTickets(0);
+      expect(tickets.length).to.equal(1);
+      expect(tickets[0]).to.equal(0);
+    });
+
+    it("Should not allow querying non-existent events", async function () {
+      await expect(eventManager.getEventImages(1)).to.be.revertedWith("Invalid event ID");
+      await expect(eventManager.getEventTickets(1)).to.be.revertedWith("Invalid event ID");
+      await expect(eventManager.getEventPriceFlare(1)).to.be.revertedWith("Invalid event ID");
+    });
+  });
+});

tsconfig.hardhat.json

@@ -0,0 +1,13 @@
+{
+    "compilerOptions": {
+      "target": "es2020",
+      "module": "commonjs",
+      "esModuleInterop": true,
+      "forceConsistentCasingInFileNames": true,
+      "strict": true,
+      "skipLibCheck": true,
+      "resolveJsonModule": true
+    },
+    "include": ["./scripts", "./test", "./hardhat.config.ts"],
+    "files": ["./hardhat.config.ts"]
+  }

tsconfig.json

@@ -22,5 +22,5 @@
     }
   },
   "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
-  "exclude": ["node_modules"]
+  "exclude": ["node_modules", "test", "scripts", "hardhat.config.ts"]
 }

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/FtsoV2Interface.ts

@@ -0,0 +1,522 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  PayableOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export declare namespace FtsoV2Interface {
+  export type FeedDataStruct = {
+    votingRoundId: PromiseOrValue<BigNumberish>;
+    id: PromiseOrValue<BytesLike>;
+    value: PromiseOrValue<BigNumberish>;
+    turnoutBIPS: PromiseOrValue<BigNumberish>;
+    decimals: PromiseOrValue<BigNumberish>;
+  };
+
+  export type FeedDataStructOutput = [
+    number,
+    string,
+    number,
+    number,
+    number
+  ] & {
+    votingRoundId: number;
+    id: string;
+    value: number;
+    turnoutBIPS: number;
+    decimals: number;
+  };
+
+  export type FeedDataWithProofStruct = {
+    proof: PromiseOrValue<BytesLike>[];
+    body: FtsoV2Interface.FeedDataStruct;
+  };
+
+  export type FeedDataWithProofStructOutput = [
+    string[],
+    FtsoV2Interface.FeedDataStructOutput
+  ] & { proof: string[]; body: FtsoV2Interface.FeedDataStructOutput };
+}
+
+export interface FtsoV2InterfaceInterface extends utils.Interface {
+  functions: {
+    "getFeedById(bytes21)": FunctionFragment;
+    "getFeedByIdInWei(bytes21)": FunctionFragment;
+    "getFeedByIndex(uint256)": FunctionFragment;
+    "getFeedByIndexInWei(uint256)": FunctionFragment;
+    "getFeedId(uint256)": FunctionFragment;
+    "getFeedIndex(bytes21)": FunctionFragment;
+    "getFeedsById(bytes21[])": FunctionFragment;
+    "getFeedsByIdInWei(bytes21[])": FunctionFragment;
+    "getFeedsByIndex(uint256[])": FunctionFragment;
+    "getFeedsByIndexInWei(uint256[])": FunctionFragment;
+    "verifyFeedData((bytes32[],(uint32,bytes21,int32,uint16,int8)))": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "getFeedById"
+      | "getFeedByIdInWei"
+      | "getFeedByIndex"
+      | "getFeedByIndexInWei"
+      | "getFeedId"
+      | "getFeedIndex"
+      | "getFeedsById"
+      | "getFeedsByIdInWei"
+      | "getFeedsByIndex"
+      | "getFeedsByIndexInWei"
+      | "verifyFeedData"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "getFeedById",
+    values: [PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFeedByIdInWei",
+    values: [PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFeedByIndex",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFeedByIndexInWei",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFeedId",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFeedIndex",
+    values: [PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFeedsById",
+    values: [PromiseOrValue<BytesLike>[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFeedsByIdInWei",
+    values: [PromiseOrValue<BytesLike>[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFeedsByIndex",
+    values: [PromiseOrValue<BigNumberish>[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFeedsByIndexInWei",
+    values: [PromiseOrValue<BigNumberish>[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "verifyFeedData",
+    values: [FtsoV2Interface.FeedDataWithProofStruct]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "getFeedById",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getFeedByIdInWei",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getFeedByIndex",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getFeedByIndexInWei",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getFeedId", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getFeedIndex",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getFeedsById",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getFeedsByIdInWei",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getFeedsByIndex",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getFeedsByIndexInWei",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "verifyFeedData",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface FtsoV2Interface extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: FtsoV2InterfaceInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    getFeedById(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    getFeedByIdInWei(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    getFeedByIndex(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    getFeedByIndexInWei(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    getFeedId(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[string] & { _feedId: string }>;
+
+    getFeedIndex(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { _index: BigNumber }>;
+
+    getFeedsById(
+      _feedIds: PromiseOrValue<BytesLike>[],
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    getFeedsByIdInWei(
+      _feedIds: PromiseOrValue<BytesLike>[],
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    getFeedsByIndex(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    getFeedsByIndexInWei(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    verifyFeedData(
+      _feedData: FtsoV2Interface.FeedDataWithProofStruct,
+      overrides?: CallOverrides
+    ): Promise<[boolean]>;
+  };
+
+  getFeedById(
+    _feedId: PromiseOrValue<BytesLike>,
+    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  getFeedByIdInWei(
+    _feedId: PromiseOrValue<BytesLike>,
+    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  getFeedByIndex(
+    _index: PromiseOrValue<BigNumberish>,
+    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  getFeedByIndexInWei(
+    _index: PromiseOrValue<BigNumberish>,
+    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  getFeedId(
+    _index: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  getFeedIndex(
+    _feedId: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  getFeedsById(
+    _feedIds: PromiseOrValue<BytesLike>[],
+    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  getFeedsByIdInWei(
+    _feedIds: PromiseOrValue<BytesLike>[],
+    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  getFeedsByIndex(
+    _indices: PromiseOrValue<BigNumberish>[],
+    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  getFeedsByIndexInWei(
+    _indices: PromiseOrValue<BigNumberish>[],
+    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  verifyFeedData(
+    _feedData: FtsoV2Interface.FeedDataWithProofStruct,
+    overrides?: CallOverrides
+  ): Promise<boolean>;
+
+  callStatic: {
+    getFeedById(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, number, BigNumber] & {
+        _value: BigNumber;
+        _decimals: number;
+        _timestamp: BigNumber;
+      }
+    >;
+
+    getFeedByIdInWei(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { _value: BigNumber; _timestamp: BigNumber }
+    >;
+
+    getFeedByIndex(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, number, BigNumber] & {
+        _value: BigNumber;
+        _decimals: number;
+        _timestamp: BigNumber;
+      }
+    >;
+
+    getFeedByIndexInWei(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { _value: BigNumber; _timestamp: BigNumber }
+    >;
+
+    getFeedId(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    getFeedIndex(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getFeedsById(
+      _feedIds: PromiseOrValue<BytesLike>[],
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber[], number[], BigNumber] & {
+        _values: BigNumber[];
+        _decimals: number[];
+        _timestamp: BigNumber;
+      }
+    >;
+
+    getFeedsByIdInWei(
+      _feedIds: PromiseOrValue<BytesLike>[],
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber[], BigNumber] & { _values: BigNumber[]; _timestamp: BigNumber }
+    >;
+
+    getFeedsByIndex(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber[], number[], BigNumber] & {
+        _values: BigNumber[];
+        _decimals: number[];
+        _timestamp: BigNumber;
+      }
+    >;
+
+    getFeedsByIndexInWei(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber[], BigNumber] & { _values: BigNumber[]; _timestamp: BigNumber }
+    >;
+
+    verifyFeedData(
+      _feedData: FtsoV2Interface.FeedDataWithProofStruct,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    getFeedById(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    getFeedByIdInWei(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    getFeedByIndex(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    getFeedByIndexInWei(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    getFeedId(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getFeedIndex(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getFeedsById(
+      _feedIds: PromiseOrValue<BytesLike>[],
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    getFeedsByIdInWei(
+      _feedIds: PromiseOrValue<BytesLike>[],
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    getFeedsByIndex(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    getFeedsByIndexInWei(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    verifyFeedData(
+      _feedData: FtsoV2Interface.FeedDataWithProofStruct,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    getFeedById(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    getFeedByIdInWei(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    getFeedByIndex(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    getFeedByIndexInWei(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    getFeedId(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getFeedIndex(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getFeedsById(
+      _feedIds: PromiseOrValue<BytesLike>[],
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    getFeedsByIdInWei(
+      _feedIds: PromiseOrValue<BytesLike>[],
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    getFeedsByIndex(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    getFeedsByIndexInWei(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    verifyFeedData(
+      _feedData: FtsoV2Interface.FeedDataWithProofStruct,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IAddressBinder.ts

@@ -0,0 +1,259 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export interface IAddressBinderInterface extends utils.Interface {
+  functions: {
+    "cAddressToPAddress(address)": FunctionFragment;
+    "pAddressToCAddress(bytes20)": FunctionFragment;
+    "registerAddresses(bytes,bytes20,address)": FunctionFragment;
+    "registerPublicKey(bytes)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "cAddressToPAddress"
+      | "pAddressToCAddress"
+      | "registerAddresses"
+      | "registerPublicKey"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "cAddressToPAddress",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "pAddressToCAddress",
+    values: [PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "registerAddresses",
+    values: [
+      PromiseOrValue<BytesLike>,
+      PromiseOrValue<BytesLike>,
+      PromiseOrValue<string>
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "registerPublicKey",
+    values: [PromiseOrValue<BytesLike>]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "cAddressToPAddress",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "pAddressToCAddress",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "registerAddresses",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "registerPublicKey",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "AddressesRegistered(bytes,bytes20,address)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "AddressesRegistered"): EventFragment;
+}
+
+export interface AddressesRegisteredEventObject {
+  publicKey: string;
+  pAddress: string;
+  cAddress: string;
+}
+export type AddressesRegisteredEvent = TypedEvent<
+  [string, string, string],
+  AddressesRegisteredEventObject
+>;
+
+export type AddressesRegisteredEventFilter =
+  TypedEventFilter<AddressesRegisteredEvent>;
+
+export interface IAddressBinder extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IAddressBinderInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    cAddressToPAddress(
+      _cAddress: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[string] & { _pAddress: string }>;
+
+    pAddressToCAddress(
+      _pAddress: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[string] & { _cAddress: string }>;
+
+    registerAddresses(
+      _publicKey: PromiseOrValue<BytesLike>,
+      _pAddress: PromiseOrValue<BytesLike>,
+      _cAddress: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    registerPublicKey(
+      _publicKey: PromiseOrValue<BytesLike>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  cAddressToPAddress(
+    _cAddress: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  pAddressToCAddress(
+    _pAddress: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  registerAddresses(
+    _publicKey: PromiseOrValue<BytesLike>,
+    _pAddress: PromiseOrValue<BytesLike>,
+    _cAddress: PromiseOrValue<string>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  registerPublicKey(
+    _publicKey: PromiseOrValue<BytesLike>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    cAddressToPAddress(
+      _cAddress: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    pAddressToCAddress(
+      _pAddress: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    registerAddresses(
+      _publicKey: PromiseOrValue<BytesLike>,
+      _pAddress: PromiseOrValue<BytesLike>,
+      _cAddress: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    registerPublicKey(
+      _publicKey: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[string, string] & { _pAddress: string; _cAddress: string }>;
+  };
+
+  filters: {
+    "AddressesRegistered(bytes,bytes20,address)"(
+      publicKey?: null,
+      pAddress?: null,
+      cAddress?: null
+    ): AddressesRegisteredEventFilter;
+    AddressesRegistered(
+      publicKey?: null,
+      pAddress?: null,
+      cAddress?: null
+    ): AddressesRegisteredEventFilter;
+  };
+
+  estimateGas: {
+    cAddressToPAddress(
+      _cAddress: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    pAddressToCAddress(
+      _pAddress: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    registerAddresses(
+      _publicKey: PromiseOrValue<BytesLike>,
+      _pAddress: PromiseOrValue<BytesLike>,
+      _cAddress: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    registerPublicKey(
+      _publicKey: PromiseOrValue<BytesLike>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    cAddressToPAddress(
+      _cAddress: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    pAddressToCAddress(
+      _pAddress: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    registerAddresses(
+      _publicKey: PromiseOrValue<BytesLike>,
+      _pAddress: PromiseOrValue<BytesLike>,
+      _cAddress: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    registerPublicKey(
+      _publicKey: PromiseOrValue<BytesLike>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IDelegationAccount.ts

@@ -0,0 +1,215 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type { BaseContract, BigNumber, Signer, utils } from "ethers";
+import type { EventFragment } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "../../../common";
+
+export interface IDelegationAccountInterface extends utils.Interface {
+  functions: {};
+
+  events: {
+    "DelegateFtso(address,uint256)": EventFragment;
+    "DelegateGovernance(address)": EventFragment;
+    "ExecutorFeePaid(address,uint256)": EventFragment;
+    "ExternalTokenTransferred(address,uint256)": EventFragment;
+    "Initialize(address,address)": EventFragment;
+    "RevokeFtso(address,uint256)": EventFragment;
+    "UndelegateAllFtso()": EventFragment;
+    "UndelegateGovernance()": EventFragment;
+    "WithdrawToOwner(uint256)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "DelegateFtso"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "DelegateGovernance"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "ExecutorFeePaid"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "ExternalTokenTransferred"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "Initialize"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "RevokeFtso"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "UndelegateAllFtso"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "UndelegateGovernance"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "WithdrawToOwner"): EventFragment;
+}
+
+export interface DelegateFtsoEventObject {
+  to: string;
+  bips: BigNumber;
+}
+export type DelegateFtsoEvent = TypedEvent<
+  [string, BigNumber],
+  DelegateFtsoEventObject
+>;
+
+export type DelegateFtsoEventFilter = TypedEventFilter<DelegateFtsoEvent>;
+
+export interface DelegateGovernanceEventObject {
+  to: string;
+}
+export type DelegateGovernanceEvent = TypedEvent<
+  [string],
+  DelegateGovernanceEventObject
+>;
+
+export type DelegateGovernanceEventFilter =
+  TypedEventFilter<DelegateGovernanceEvent>;
+
+export interface ExecutorFeePaidEventObject {
+  executor: string;
+  amount: BigNumber;
+}
+export type ExecutorFeePaidEvent = TypedEvent<
+  [string, BigNumber],
+  ExecutorFeePaidEventObject
+>;
+
+export type ExecutorFeePaidEventFilter = TypedEventFilter<ExecutorFeePaidEvent>;
+
+export interface ExternalTokenTransferredEventObject {
+  token: string;
+  amount: BigNumber;
+}
+export type ExternalTokenTransferredEvent = TypedEvent<
+  [string, BigNumber],
+  ExternalTokenTransferredEventObject
+>;
+
+export type ExternalTokenTransferredEventFilter =
+  TypedEventFilter<ExternalTokenTransferredEvent>;
+
+export interface InitializeEventObject {
+  owner: string;
+  manager: string;
+}
+export type InitializeEvent = TypedEvent<
+  [string, string],
+  InitializeEventObject
+>;
+
+export type InitializeEventFilter = TypedEventFilter<InitializeEvent>;
+
+export interface RevokeFtsoEventObject {
+  to: string;
+  blockNumber: BigNumber;
+}
+export type RevokeFtsoEvent = TypedEvent<
+  [string, BigNumber],
+  RevokeFtsoEventObject
+>;
+
+export type RevokeFtsoEventFilter = TypedEventFilter<RevokeFtsoEvent>;
+
+export interface UndelegateAllFtsoEventObject {}
+export type UndelegateAllFtsoEvent = TypedEvent<
+  [],
+  UndelegateAllFtsoEventObject
+>;
+
+export type UndelegateAllFtsoEventFilter =
+  TypedEventFilter<UndelegateAllFtsoEvent>;
+
+export interface UndelegateGovernanceEventObject {}
+export type UndelegateGovernanceEvent = TypedEvent<
+  [],
+  UndelegateGovernanceEventObject
+>;
+
+export type UndelegateGovernanceEventFilter =
+  TypedEventFilter<UndelegateGovernanceEvent>;
+
+export interface WithdrawToOwnerEventObject {
+  amount: BigNumber;
+}
+export type WithdrawToOwnerEvent = TypedEvent<
+  [BigNumber],
+  WithdrawToOwnerEventObject
+>;
+
+export type WithdrawToOwnerEventFilter = TypedEventFilter<WithdrawToOwnerEvent>;
+
+export interface IDelegationAccount extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IDelegationAccountInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {};
+
+  callStatic: {};
+
+  filters: {
+    "DelegateFtso(address,uint256)"(
+      to?: null,
+      bips?: null
+    ): DelegateFtsoEventFilter;
+    DelegateFtso(to?: null, bips?: null): DelegateFtsoEventFilter;
+
+    "DelegateGovernance(address)"(to?: null): DelegateGovernanceEventFilter;
+    DelegateGovernance(to?: null): DelegateGovernanceEventFilter;
+
+    "ExecutorFeePaid(address,uint256)"(
+      executor?: null,
+      amount?: null
+    ): ExecutorFeePaidEventFilter;
+    ExecutorFeePaid(executor?: null, amount?: null): ExecutorFeePaidEventFilter;
+
+    "ExternalTokenTransferred(address,uint256)"(
+      token?: null,
+      amount?: null
+    ): ExternalTokenTransferredEventFilter;
+    ExternalTokenTransferred(
+      token?: null,
+      amount?: null
+    ): ExternalTokenTransferredEventFilter;
+
+    "Initialize(address,address)"(
+      owner?: null,
+      manager?: null
+    ): InitializeEventFilter;
+    Initialize(owner?: null, manager?: null): InitializeEventFilter;
+
+    "RevokeFtso(address,uint256)"(
+      to?: null,
+      blockNumber?: null
+    ): RevokeFtsoEventFilter;
+    RevokeFtso(to?: null, blockNumber?: null): RevokeFtsoEventFilter;
+
+    "UndelegateAllFtso()"(): UndelegateAllFtsoEventFilter;
+    UndelegateAllFtso(): UndelegateAllFtsoEventFilter;
+
+    "UndelegateGovernance()"(): UndelegateGovernanceEventFilter;
+    UndelegateGovernance(): UndelegateGovernanceEventFilter;
+
+    "WithdrawToOwner(uint256)"(amount?: null): WithdrawToOwnerEventFilter;
+    WithdrawToOwner(amount?: null): WithdrawToOwnerEventFilter;
+  };
+
+  estimateGas: {};
+
+  populateTransaction: {};
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IDistributionToDelegators.ts

@@ -0,0 +1,478 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export interface IDistributionToDelegatorsInterface extends utils.Interface {
+  functions: {
+    "autoClaim(address[],uint256)": FunctionFragment;
+    "claim(address,address,uint256,bool)": FunctionFragment;
+    "getClaimableAmount(uint256)": FunctionFragment;
+    "getClaimableAmountOf(address,uint256)": FunctionFragment;
+    "getClaimableMonths()": FunctionFragment;
+    "getCurrentMonth()": FunctionFragment;
+    "getMonthToExpireNext()": FunctionFragment;
+    "nextClaimableMonth(address)": FunctionFragment;
+    "optOutOfAirdrop()": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "autoClaim"
+      | "claim"
+      | "getClaimableAmount"
+      | "getClaimableAmountOf"
+      | "getClaimableMonths"
+      | "getCurrentMonth"
+      | "getMonthToExpireNext"
+      | "nextClaimableMonth"
+      | "optOutOfAirdrop"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "autoClaim",
+    values: [PromiseOrValue<string>[], PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "claim",
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<boolean>
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getClaimableAmount",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getClaimableAmountOf",
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getClaimableMonths",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentMonth",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getMonthToExpireNext",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "nextClaimableMonth",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "optOutOfAirdrop",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(functionFragment: "autoClaim", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "claim", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getClaimableAmount",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getClaimableAmountOf",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getClaimableMonths",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentMonth",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getMonthToExpireNext",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "nextClaimableMonth",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "optOutOfAirdrop",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "AccountClaimed(address,address,uint256,uint256)": EventFragment;
+    "AccountOptOut(address,bool)": EventFragment;
+    "EntitlementStart(uint256)": EventFragment;
+    "UseGoodRandomSet(bool,uint256)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "AccountClaimed"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "AccountOptOut"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "EntitlementStart"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "UseGoodRandomSet"): EventFragment;
+}
+
+export interface AccountClaimedEventObject {
+  whoClaimed: string;
+  sentTo: string;
+  month: BigNumber;
+  amountWei: BigNumber;
+}
+export type AccountClaimedEvent = TypedEvent<
+  [string, string, BigNumber, BigNumber],
+  AccountClaimedEventObject
+>;
+
+export type AccountClaimedEventFilter = TypedEventFilter<AccountClaimedEvent>;
+
+export interface AccountOptOutEventObject {
+  theAccount: string;
+  confirmed: boolean;
+}
+export type AccountOptOutEvent = TypedEvent<
+  [string, boolean],
+  AccountOptOutEventObject
+>;
+
+export type AccountOptOutEventFilter = TypedEventFilter<AccountOptOutEvent>;
+
+export interface EntitlementStartEventObject {
+  entitlementStartTs: BigNumber;
+}
+export type EntitlementStartEvent = TypedEvent<
+  [BigNumber],
+  EntitlementStartEventObject
+>;
+
+export type EntitlementStartEventFilter =
+  TypedEventFilter<EntitlementStartEvent>;
+
+export interface UseGoodRandomSetEventObject {
+  useGoodRandom: boolean;
+  maxWaitForGoodRandomSeconds: BigNumber;
+}
+export type UseGoodRandomSetEvent = TypedEvent<
+  [boolean, BigNumber],
+  UseGoodRandomSetEventObject
+>;
+
+export type UseGoodRandomSetEventFilter =
+  TypedEventFilter<UseGoodRandomSetEvent>;
+
+export interface IDistributionToDelegators extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IDistributionToDelegatorsInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    autoClaim(
+      _rewardOwners: PromiseOrValue<string>[],
+      _month: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    claim(
+      _rewardOwner: PromiseOrValue<string>,
+      _recipient: PromiseOrValue<string>,
+      _month: PromiseOrValue<BigNumberish>,
+      _wrap: PromiseOrValue<boolean>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    getClaimableAmount(
+      _month: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { _amountWei: BigNumber }>;
+
+    getClaimableAmountOf(
+      _account: PromiseOrValue<string>,
+      _month: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { _amountWei: BigNumber }>;
+
+    getClaimableMonths(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { _startMonth: BigNumber; _endMonth: BigNumber }
+    >;
+
+    getCurrentMonth(
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { _currentMonth: BigNumber }>;
+
+    getMonthToExpireNext(
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { _monthToExpireNext: BigNumber }>;
+
+    nextClaimableMonth(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    optOutOfAirdrop(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  autoClaim(
+    _rewardOwners: PromiseOrValue<string>[],
+    _month: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  claim(
+    _rewardOwner: PromiseOrValue<string>,
+    _recipient: PromiseOrValue<string>,
+    _month: PromiseOrValue<BigNumberish>,
+    _wrap: PromiseOrValue<boolean>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  getClaimableAmount(
+    _month: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  getClaimableAmountOf(
+    _account: PromiseOrValue<string>,
+    _month: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  getClaimableMonths(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber] & { _startMonth: BigNumber; _endMonth: BigNumber }
+  >;
+
+  getCurrentMonth(overrides?: CallOverrides): Promise<BigNumber>;
+
+  getMonthToExpireNext(overrides?: CallOverrides): Promise<BigNumber>;
+
+  nextClaimableMonth(
+    _rewardOwner: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  optOutOfAirdrop(
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    autoClaim(
+      _rewardOwners: PromiseOrValue<string>[],
+      _month: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    claim(
+      _rewardOwner: PromiseOrValue<string>,
+      _recipient: PromiseOrValue<string>,
+      _month: PromiseOrValue<BigNumberish>,
+      _wrap: PromiseOrValue<boolean>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getClaimableAmount(
+      _month: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getClaimableAmountOf(
+      _account: PromiseOrValue<string>,
+      _month: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getClaimableMonths(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { _startMonth: BigNumber; _endMonth: BigNumber }
+    >;
+
+    getCurrentMonth(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getMonthToExpireNext(overrides?: CallOverrides): Promise<BigNumber>;
+
+    nextClaimableMonth(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    optOutOfAirdrop(overrides?: CallOverrides): Promise<void>;
+  };
+
+  filters: {
+    "AccountClaimed(address,address,uint256,uint256)"(
+      whoClaimed?: PromiseOrValue<string> | null,
+      sentTo?: PromiseOrValue<string> | null,
+      month?: null,
+      amountWei?: null
+    ): AccountClaimedEventFilter;
+    AccountClaimed(
+      whoClaimed?: PromiseOrValue<string> | null,
+      sentTo?: PromiseOrValue<string> | null,
+      month?: null,
+      amountWei?: null
+    ): AccountClaimedEventFilter;
+
+    "AccountOptOut(address,bool)"(
+      theAccount?: PromiseOrValue<string> | null,
+      confirmed?: null
+    ): AccountOptOutEventFilter;
+    AccountOptOut(
+      theAccount?: PromiseOrValue<string> | null,
+      confirmed?: null
+    ): AccountOptOutEventFilter;
+
+    "EntitlementStart(uint256)"(
+      entitlementStartTs?: null
+    ): EntitlementStartEventFilter;
+    EntitlementStart(entitlementStartTs?: null): EntitlementStartEventFilter;
+
+    "UseGoodRandomSet(bool,uint256)"(
+      useGoodRandom?: null,
+      maxWaitForGoodRandomSeconds?: null
+    ): UseGoodRandomSetEventFilter;
+    UseGoodRandomSet(
+      useGoodRandom?: null,
+      maxWaitForGoodRandomSeconds?: null
+    ): UseGoodRandomSetEventFilter;
+  };
+
+  estimateGas: {
+    autoClaim(
+      _rewardOwners: PromiseOrValue<string>[],
+      _month: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    claim(
+      _rewardOwner: PromiseOrValue<string>,
+      _recipient: PromiseOrValue<string>,
+      _month: PromiseOrValue<BigNumberish>,
+      _wrap: PromiseOrValue<boolean>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    getClaimableAmount(
+      _month: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getClaimableAmountOf(
+      _account: PromiseOrValue<string>,
+      _month: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getClaimableMonths(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentMonth(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getMonthToExpireNext(overrides?: CallOverrides): Promise<BigNumber>;
+
+    nextClaimableMonth(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    optOutOfAirdrop(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    autoClaim(
+      _rewardOwners: PromiseOrValue<string>[],
+      _month: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    claim(
+      _rewardOwner: PromiseOrValue<string>,
+      _recipient: PromiseOrValue<string>,
+      _month: PromiseOrValue<BigNumberish>,
+      _wrap: PromiseOrValue<boolean>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    getClaimableAmount(
+      _month: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getClaimableAmountOf(
+      _account: PromiseOrValue<string>,
+      _month: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getClaimableMonths(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getCurrentMonth(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getMonthToExpireNext(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    nextClaimableMonth(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    optOutOfAirdrop(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IFastUpdateIncentiveManager.ts

@@ -0,0 +1,408 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  PayableOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export declare namespace IFastUpdatesConfiguration {
+  export type FeedConfigurationStruct = {
+    feedId: PromiseOrValue<BytesLike>;
+    rewardBandValue: PromiseOrValue<BigNumberish>;
+    inflationShare: PromiseOrValue<BigNumberish>;
+  };
+
+  export type FeedConfigurationStructOutput = [string, number, number] & {
+    feedId: string;
+    rewardBandValue: number;
+    inflationShare: number;
+  };
+}
+
+export declare namespace IFastUpdateIncentiveManager {
+  export type IncentiveOfferStruct = {
+    rangeIncrease: PromiseOrValue<BigNumberish>;
+    rangeLimit: PromiseOrValue<BigNumberish>;
+  };
+
+  export type IncentiveOfferStructOutput = [BigNumber, BigNumber] & {
+    rangeIncrease: BigNumber;
+    rangeLimit: BigNumber;
+  };
+}
+
+export interface IFastUpdateIncentiveManagerInterface extends utils.Interface {
+  functions: {
+    "getBaseScale()": FunctionFragment;
+    "getCurrentSampleSizeIncreasePrice()": FunctionFragment;
+    "getExpectedSampleSize()": FunctionFragment;
+    "getIncentiveDuration()": FunctionFragment;
+    "getPrecision()": FunctionFragment;
+    "getRange()": FunctionFragment;
+    "getScale()": FunctionFragment;
+    "offerIncentive((uint256,uint256))": FunctionFragment;
+    "rangeIncreaseLimit()": FunctionFragment;
+    "rangeIncreasePrice()": FunctionFragment;
+    "sampleIncreaseLimit()": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "getBaseScale"
+      | "getCurrentSampleSizeIncreasePrice"
+      | "getExpectedSampleSize"
+      | "getIncentiveDuration"
+      | "getPrecision"
+      | "getRange"
+      | "getScale"
+      | "offerIncentive"
+      | "rangeIncreaseLimit"
+      | "rangeIncreasePrice"
+      | "sampleIncreaseLimit"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "getBaseScale",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentSampleSizeIncreasePrice",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getExpectedSampleSize",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getIncentiveDuration",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getPrecision",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "getRange", values?: undefined): string;
+  encodeFunctionData(functionFragment: "getScale", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "offerIncentive",
+    values: [IFastUpdateIncentiveManager.IncentiveOfferStruct]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "rangeIncreaseLimit",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "rangeIncreasePrice",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "sampleIncreaseLimit",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "getBaseScale",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentSampleSizeIncreasePrice",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getExpectedSampleSize",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getIncentiveDuration",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getPrecision",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getRange", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "getScale", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "offerIncentive",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "rangeIncreaseLimit",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "rangeIncreasePrice",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "sampleIncreaseLimit",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "IncentiveOffered(uint24,uint256,uint256,uint256)": EventFragment;
+    "InflationRewardsOffered(uint24,tuple[],uint256)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "IncentiveOffered"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "InflationRewardsOffered"): EventFragment;
+}
+
+export interface IncentiveOfferedEventObject {
+  rewardEpochId: number;
+  rangeIncrease: BigNumber;
+  sampleSizeIncrease: BigNumber;
+  offerAmount: BigNumber;
+}
+export type IncentiveOfferedEvent = TypedEvent<
+  [number, BigNumber, BigNumber, BigNumber],
+  IncentiveOfferedEventObject
+>;
+
+export type IncentiveOfferedEventFilter =
+  TypedEventFilter<IncentiveOfferedEvent>;
+
+export interface InflationRewardsOfferedEventObject {
+  rewardEpochId: number;
+  feedConfigurations: IFastUpdatesConfiguration.FeedConfigurationStructOutput[];
+  amount: BigNumber;
+}
+export type InflationRewardsOfferedEvent = TypedEvent<
+  [
+    number,
+    IFastUpdatesConfiguration.FeedConfigurationStructOutput[],
+    BigNumber
+  ],
+  InflationRewardsOfferedEventObject
+>;
+
+export type InflationRewardsOfferedEventFilter =
+  TypedEventFilter<InflationRewardsOfferedEvent>;
+
+export interface IFastUpdateIncentiveManager extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IFastUpdateIncentiveManagerInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    getBaseScale(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    getCurrentSampleSizeIncreasePrice(
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    getExpectedSampleSize(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    getIncentiveDuration(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    getPrecision(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    getRange(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    getScale(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    offerIncentive(
+      _offer: IFastUpdateIncentiveManager.IncentiveOfferStruct,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    rangeIncreaseLimit(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    rangeIncreasePrice(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    sampleIncreaseLimit(overrides?: CallOverrides): Promise<[BigNumber]>;
+  };
+
+  getBaseScale(overrides?: CallOverrides): Promise<BigNumber>;
+
+  getCurrentSampleSizeIncreasePrice(
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  getExpectedSampleSize(overrides?: CallOverrides): Promise<BigNumber>;
+
+  getIncentiveDuration(overrides?: CallOverrides): Promise<BigNumber>;
+
+  getPrecision(overrides?: CallOverrides): Promise<BigNumber>;
+
+  getRange(overrides?: CallOverrides): Promise<BigNumber>;
+
+  getScale(overrides?: CallOverrides): Promise<BigNumber>;
+
+  offerIncentive(
+    _offer: IFastUpdateIncentiveManager.IncentiveOfferStruct,
+    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  rangeIncreaseLimit(overrides?: CallOverrides): Promise<BigNumber>;
+
+  rangeIncreasePrice(overrides?: CallOverrides): Promise<BigNumber>;
+
+  sampleIncreaseLimit(overrides?: CallOverrides): Promise<BigNumber>;
+
+  callStatic: {
+    getBaseScale(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentSampleSizeIncreasePrice(
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getExpectedSampleSize(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getIncentiveDuration(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getPrecision(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getRange(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getScale(overrides?: CallOverrides): Promise<BigNumber>;
+
+    offerIncentive(
+      _offer: IFastUpdateIncentiveManager.IncentiveOfferStruct,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    rangeIncreaseLimit(overrides?: CallOverrides): Promise<BigNumber>;
+
+    rangeIncreasePrice(overrides?: CallOverrides): Promise<BigNumber>;
+
+    sampleIncreaseLimit(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  filters: {
+    "IncentiveOffered(uint24,uint256,uint256,uint256)"(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      rangeIncrease?: null,
+      sampleSizeIncrease?: null,
+      offerAmount?: null
+    ): IncentiveOfferedEventFilter;
+    IncentiveOffered(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      rangeIncrease?: null,
+      sampleSizeIncrease?: null,
+      offerAmount?: null
+    ): IncentiveOfferedEventFilter;
+
+    "InflationRewardsOffered(uint24,tuple[],uint256)"(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      feedConfigurations?: null,
+      amount?: null
+    ): InflationRewardsOfferedEventFilter;
+    InflationRewardsOffered(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      feedConfigurations?: null,
+      amount?: null
+    ): InflationRewardsOfferedEventFilter;
+  };
+
+  estimateGas: {
+    getBaseScale(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentSampleSizeIncreasePrice(
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getExpectedSampleSize(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getIncentiveDuration(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getPrecision(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getRange(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getScale(overrides?: CallOverrides): Promise<BigNumber>;
+
+    offerIncentive(
+      _offer: IFastUpdateIncentiveManager.IncentiveOfferStruct,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    rangeIncreaseLimit(overrides?: CallOverrides): Promise<BigNumber>;
+
+    rangeIncreasePrice(overrides?: CallOverrides): Promise<BigNumber>;
+
+    sampleIncreaseLimit(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    getBaseScale(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getCurrentSampleSizeIncreasePrice(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getExpectedSampleSize(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getIncentiveDuration(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getPrecision(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getRange(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getScale(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    offerIncentive(
+      _offer: IFastUpdateIncentiveManager.IncentiveOfferStruct,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    rangeIncreaseLimit(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    rangeIncreasePrice(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    sampleIncreaseLimit(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IFastUpdater.ts

@@ -0,0 +1,562 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PayableOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export type G1PointStruct = {
+  x: PromiseOrValue<BigNumberish>;
+  y: PromiseOrValue<BigNumberish>;
+};
+
+export type G1PointStructOutput = [BigNumber, BigNumber] & {
+  x: BigNumber;
+  y: BigNumber;
+};
+
+export type SortitionCredentialStruct = {
+  replicate: PromiseOrValue<BigNumberish>;
+  gamma: G1PointStruct;
+  c: PromiseOrValue<BigNumberish>;
+  s: PromiseOrValue<BigNumberish>;
+};
+
+export type SortitionCredentialStructOutput = [
+  BigNumber,
+  G1PointStructOutput,
+  BigNumber,
+  BigNumber
+] & {
+  replicate: BigNumber;
+  gamma: G1PointStructOutput;
+  c: BigNumber;
+  s: BigNumber;
+};
+
+export declare namespace IFastUpdater {
+  export type SignatureStruct = {
+    v: PromiseOrValue<BigNumberish>;
+    r: PromiseOrValue<BytesLike>;
+    s: PromiseOrValue<BytesLike>;
+  };
+
+  export type SignatureStructOutput = [number, string, string] & {
+    v: number;
+    r: string;
+    s: string;
+  };
+
+  export type FastUpdatesStruct = {
+    sortitionBlock: PromiseOrValue<BigNumberish>;
+    sortitionCredential: SortitionCredentialStruct;
+    deltas: PromiseOrValue<BytesLike>;
+    signature: IFastUpdater.SignatureStruct;
+  };
+
+  export type FastUpdatesStructOutput = [
+    BigNumber,
+    SortitionCredentialStructOutput,
+    string,
+    IFastUpdater.SignatureStructOutput
+  ] & {
+    sortitionBlock: BigNumber;
+    sortitionCredential: SortitionCredentialStructOutput;
+    deltas: string;
+    signature: IFastUpdater.SignatureStructOutput;
+  };
+}
+
+export interface IFastUpdaterInterface extends utils.Interface {
+  functions: {
+    "blockScoreCutoff(uint256)": FunctionFragment;
+    "currentRewardEpochId()": FunctionFragment;
+    "currentScoreCutoff()": FunctionFragment;
+    "currentSortitionWeight(address)": FunctionFragment;
+    "fetchAllCurrentFeeds()": FunctionFragment;
+    "fetchCurrentFeeds(uint256[])": FunctionFragment;
+    "numberOfUpdates(uint256)": FunctionFragment;
+    "numberOfUpdatesInBlock(uint256)": FunctionFragment;
+    "submissionWindow()": FunctionFragment;
+    "submitUpdates((uint256,(uint256,(uint256,uint256),uint256,uint256),bytes,(uint8,bytes32,bytes32)))": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "blockScoreCutoff"
+      | "currentRewardEpochId"
+      | "currentScoreCutoff"
+      | "currentSortitionWeight"
+      | "fetchAllCurrentFeeds"
+      | "fetchCurrentFeeds"
+      | "numberOfUpdates"
+      | "numberOfUpdatesInBlock"
+      | "submissionWindow"
+      | "submitUpdates"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "blockScoreCutoff",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "currentRewardEpochId",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "currentScoreCutoff",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "currentSortitionWeight",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "fetchAllCurrentFeeds",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "fetchCurrentFeeds",
+    values: [PromiseOrValue<BigNumberish>[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "numberOfUpdates",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "numberOfUpdatesInBlock",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "submissionWindow",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "submitUpdates",
+    values: [IFastUpdater.FastUpdatesStruct]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "blockScoreCutoff",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "currentRewardEpochId",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "currentScoreCutoff",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "currentSortitionWeight",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "fetchAllCurrentFeeds",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "fetchCurrentFeeds",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "numberOfUpdates",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "numberOfUpdatesInBlock",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "submissionWindow",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "submitUpdates",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "FastUpdateFeedRemoved(uint256)": EventFragment;
+    "FastUpdateFeedReset(uint256,uint256,bytes21,uint256,int8)": EventFragment;
+    "FastUpdateFeeds(uint256,uint256[],int8[])": EventFragment;
+    "FastUpdateFeedsSubmitted(uint32,address)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "FastUpdateFeedRemoved"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "FastUpdateFeedReset"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "FastUpdateFeeds"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "FastUpdateFeedsSubmitted"): EventFragment;
+}
+
+export interface FastUpdateFeedRemovedEventObject {
+  index: BigNumber;
+}
+export type FastUpdateFeedRemovedEvent = TypedEvent<
+  [BigNumber],
+  FastUpdateFeedRemovedEventObject
+>;
+
+export type FastUpdateFeedRemovedEventFilter =
+  TypedEventFilter<FastUpdateFeedRemovedEvent>;
+
+export interface FastUpdateFeedResetEventObject {
+  votingRoundId: BigNumber;
+  index: BigNumber;
+  id: string;
+  value: BigNumber;
+  decimals: number;
+}
+export type FastUpdateFeedResetEvent = TypedEvent<
+  [BigNumber, BigNumber, string, BigNumber, number],
+  FastUpdateFeedResetEventObject
+>;
+
+export type FastUpdateFeedResetEventFilter =
+  TypedEventFilter<FastUpdateFeedResetEvent>;
+
+export interface FastUpdateFeedsEventObject {
+  votingEpochId: BigNumber;
+  feeds: BigNumber[];
+  decimals: number[];
+}
+export type FastUpdateFeedsEvent = TypedEvent<
+  [BigNumber, BigNumber[], number[]],
+  FastUpdateFeedsEventObject
+>;
+
+export type FastUpdateFeedsEventFilter = TypedEventFilter<FastUpdateFeedsEvent>;
+
+export interface FastUpdateFeedsSubmittedEventObject {
+  votingRoundId: number;
+  signingPolicyAddress: string;
+}
+export type FastUpdateFeedsSubmittedEvent = TypedEvent<
+  [number, string],
+  FastUpdateFeedsSubmittedEventObject
+>;
+
+export type FastUpdateFeedsSubmittedEventFilter =
+  TypedEventFilter<FastUpdateFeedsSubmittedEvent>;
+
+export interface IFastUpdater extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IFastUpdaterInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    blockScoreCutoff(
+      _blockNum: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { _cutoff: BigNumber }>;
+
+    currentRewardEpochId(overrides?: CallOverrides): Promise<[number]>;
+
+    currentScoreCutoff(
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { _cutoff: BigNumber }>;
+
+    currentSortitionWeight(
+      _signingPolicyAddress: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { _weight: BigNumber }>;
+
+    fetchAllCurrentFeeds(
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    fetchCurrentFeeds(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    numberOfUpdates(
+      _historySize: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber[]] & { _noOfUpdates: BigNumber[] }>;
+
+    numberOfUpdatesInBlock(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { _noOfUpdates: BigNumber }>;
+
+    submissionWindow(overrides?: CallOverrides): Promise<[number]>;
+
+    submitUpdates(
+      _updates: IFastUpdater.FastUpdatesStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  blockScoreCutoff(
+    _blockNum: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  currentRewardEpochId(overrides?: CallOverrides): Promise<number>;
+
+  currentScoreCutoff(overrides?: CallOverrides): Promise<BigNumber>;
+
+  currentSortitionWeight(
+    _signingPolicyAddress: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  fetchAllCurrentFeeds(
+    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  fetchCurrentFeeds(
+    _indices: PromiseOrValue<BigNumberish>[],
+    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  numberOfUpdates(
+    _historySize: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber[]>;
+
+  numberOfUpdatesInBlock(
+    _blockNumber: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  submissionWindow(overrides?: CallOverrides): Promise<number>;
+
+  submitUpdates(
+    _updates: IFastUpdater.FastUpdatesStruct,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    blockScoreCutoff(
+      _blockNum: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    currentRewardEpochId(overrides?: CallOverrides): Promise<number>;
+
+    currentScoreCutoff(overrides?: CallOverrides): Promise<BigNumber>;
+
+    currentSortitionWeight(
+      _signingPolicyAddress: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    fetchAllCurrentFeeds(
+      overrides?: CallOverrides
+    ): Promise<
+      [string[], BigNumber[], number[], BigNumber] & {
+        _feedIds: string[];
+        _feeds: BigNumber[];
+        _decimals: number[];
+        _timestamp: BigNumber;
+      }
+    >;
+
+    fetchCurrentFeeds(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber[], number[], BigNumber] & {
+        _feeds: BigNumber[];
+        _decimals: number[];
+        _timestamp: BigNumber;
+      }
+    >;
+
+    numberOfUpdates(
+      _historySize: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber[]>;
+
+    numberOfUpdatesInBlock(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    submissionWindow(overrides?: CallOverrides): Promise<number>;
+
+    submitUpdates(
+      _updates: IFastUpdater.FastUpdatesStruct,
+      overrides?: CallOverrides
+    ): Promise<void>;
+  };
+
+  filters: {
+    "FastUpdateFeedRemoved(uint256)"(
+      index?: PromiseOrValue<BigNumberish> | null
+    ): FastUpdateFeedRemovedEventFilter;
+    FastUpdateFeedRemoved(
+      index?: PromiseOrValue<BigNumberish> | null
+    ): FastUpdateFeedRemovedEventFilter;
+
+    "FastUpdateFeedReset(uint256,uint256,bytes21,uint256,int8)"(
+      votingRoundId?: PromiseOrValue<BigNumberish> | null,
+      index?: PromiseOrValue<BigNumberish> | null,
+      id?: PromiseOrValue<BytesLike> | null,
+      value?: null,
+      decimals?: null
+    ): FastUpdateFeedResetEventFilter;
+    FastUpdateFeedReset(
+      votingRoundId?: PromiseOrValue<BigNumberish> | null,
+      index?: PromiseOrValue<BigNumberish> | null,
+      id?: PromiseOrValue<BytesLike> | null,
+      value?: null,
+      decimals?: null
+    ): FastUpdateFeedResetEventFilter;
+
+    "FastUpdateFeeds(uint256,uint256[],int8[])"(
+      votingEpochId?: PromiseOrValue<BigNumberish> | null,
+      feeds?: null,
+      decimals?: null
+    ): FastUpdateFeedsEventFilter;
+    FastUpdateFeeds(
+      votingEpochId?: PromiseOrValue<BigNumberish> | null,
+      feeds?: null,
+      decimals?: null
+    ): FastUpdateFeedsEventFilter;
+
+    "FastUpdateFeedsSubmitted(uint32,address)"(
+      votingRoundId?: PromiseOrValue<BigNumberish> | null,
+      signingPolicyAddress?: PromiseOrValue<string> | null
+    ): FastUpdateFeedsSubmittedEventFilter;
+    FastUpdateFeedsSubmitted(
+      votingRoundId?: PromiseOrValue<BigNumberish> | null,
+      signingPolicyAddress?: PromiseOrValue<string> | null
+    ): FastUpdateFeedsSubmittedEventFilter;
+  };
+
+  estimateGas: {
+    blockScoreCutoff(
+      _blockNum: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    currentRewardEpochId(overrides?: CallOverrides): Promise<BigNumber>;
+
+    currentScoreCutoff(overrides?: CallOverrides): Promise<BigNumber>;
+
+    currentSortitionWeight(
+      _signingPolicyAddress: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    fetchAllCurrentFeeds(
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    fetchCurrentFeeds(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    numberOfUpdates(
+      _historySize: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    numberOfUpdatesInBlock(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    submissionWindow(overrides?: CallOverrides): Promise<BigNumber>;
+
+    submitUpdates(
+      _updates: IFastUpdater.FastUpdatesStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    blockScoreCutoff(
+      _blockNum: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    currentRewardEpochId(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    currentScoreCutoff(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    currentSortitionWeight(
+      _signingPolicyAddress: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    fetchAllCurrentFeeds(
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    fetchCurrentFeeds(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    numberOfUpdates(
+      _historySize: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    numberOfUpdatesInBlock(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    submissionWindow(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    submitUpdates(
+      _updates: IFastUpdater.FastUpdatesStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IFastUpdatesConfiguration.ts

@@ -0,0 +1,322 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export declare namespace IFastUpdatesConfiguration {
+  export type FeedConfigurationStruct = {
+    feedId: PromiseOrValue<BytesLike>;
+    rewardBandValue: PromiseOrValue<BigNumberish>;
+    inflationShare: PromiseOrValue<BigNumberish>;
+  };
+
+  export type FeedConfigurationStructOutput = [string, number, number] & {
+    feedId: string;
+    rewardBandValue: number;
+    inflationShare: number;
+  };
+}
+
+export interface IFastUpdatesConfigurationInterface extends utils.Interface {
+  functions: {
+    "getFeedConfigurations()": FunctionFragment;
+    "getFeedId(uint256)": FunctionFragment;
+    "getFeedIds()": FunctionFragment;
+    "getFeedIndex(bytes21)": FunctionFragment;
+    "getNumberOfFeeds()": FunctionFragment;
+    "getUnusedIndices()": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "getFeedConfigurations"
+      | "getFeedId"
+      | "getFeedIds"
+      | "getFeedIndex"
+      | "getNumberOfFeeds"
+      | "getUnusedIndices"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "getFeedConfigurations",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFeedId",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFeedIds",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFeedIndex",
+    values: [PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getNumberOfFeeds",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getUnusedIndices",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "getFeedConfigurations",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getFeedId", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "getFeedIds", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getFeedIndex",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getNumberOfFeeds",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getUnusedIndices",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "FeedAdded(bytes21,uint32,uint24,uint256)": EventFragment;
+    "FeedRemoved(bytes21,uint256)": EventFragment;
+    "FeedUpdated(bytes21,uint32,uint24,uint256)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "FeedAdded"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "FeedRemoved"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "FeedUpdated"): EventFragment;
+}
+
+export interface FeedAddedEventObject {
+  feedId: string;
+  rewardBandValue: number;
+  inflationShare: number;
+  index: BigNumber;
+}
+export type FeedAddedEvent = TypedEvent<
+  [string, number, number, BigNumber],
+  FeedAddedEventObject
+>;
+
+export type FeedAddedEventFilter = TypedEventFilter<FeedAddedEvent>;
+
+export interface FeedRemovedEventObject {
+  feedId: string;
+  index: BigNumber;
+}
+export type FeedRemovedEvent = TypedEvent<
+  [string, BigNumber],
+  FeedRemovedEventObject
+>;
+
+export type FeedRemovedEventFilter = TypedEventFilter<FeedRemovedEvent>;
+
+export interface FeedUpdatedEventObject {
+  feedId: string;
+  rewardBandValue: number;
+  inflationShare: number;
+  index: BigNumber;
+}
+export type FeedUpdatedEvent = TypedEvent<
+  [string, number, number, BigNumber],
+  FeedUpdatedEventObject
+>;
+
+export type FeedUpdatedEventFilter = TypedEventFilter<FeedUpdatedEvent>;
+
+export interface IFastUpdatesConfiguration extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IFastUpdatesConfigurationInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    getFeedConfigurations(
+      overrides?: CallOverrides
+    ): Promise<[IFastUpdatesConfiguration.FeedConfigurationStructOutput[]]>;
+
+    getFeedId(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[string] & { _feedId: string }>;
+
+    getFeedIds(overrides?: CallOverrides): Promise<[string[]]>;
+
+    getFeedIndex(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { _index: BigNumber }>;
+
+    getNumberOfFeeds(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    getUnusedIndices(overrides?: CallOverrides): Promise<[BigNumber[]]>;
+  };
+
+  getFeedConfigurations(
+    overrides?: CallOverrides
+  ): Promise<IFastUpdatesConfiguration.FeedConfigurationStructOutput[]>;
+
+  getFeedId(
+    _index: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  getFeedIds(overrides?: CallOverrides): Promise<string[]>;
+
+  getFeedIndex(
+    _feedId: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  getNumberOfFeeds(overrides?: CallOverrides): Promise<BigNumber>;
+
+  getUnusedIndices(overrides?: CallOverrides): Promise<BigNumber[]>;
+
+  callStatic: {
+    getFeedConfigurations(
+      overrides?: CallOverrides
+    ): Promise<IFastUpdatesConfiguration.FeedConfigurationStructOutput[]>;
+
+    getFeedId(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    getFeedIds(overrides?: CallOverrides): Promise<string[]>;
+
+    getFeedIndex(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getNumberOfFeeds(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getUnusedIndices(overrides?: CallOverrides): Promise<BigNumber[]>;
+  };
+
+  filters: {
+    "FeedAdded(bytes21,uint32,uint24,uint256)"(
+      feedId?: PromiseOrValue<BytesLike> | null,
+      rewardBandValue?: null,
+      inflationShare?: null,
+      index?: null
+    ): FeedAddedEventFilter;
+    FeedAdded(
+      feedId?: PromiseOrValue<BytesLike> | null,
+      rewardBandValue?: null,
+      inflationShare?: null,
+      index?: null
+    ): FeedAddedEventFilter;
+
+    "FeedRemoved(bytes21,uint256)"(
+      feedId?: PromiseOrValue<BytesLike> | null,
+      index?: null
+    ): FeedRemovedEventFilter;
+    FeedRemoved(
+      feedId?: PromiseOrValue<BytesLike> | null,
+      index?: null
+    ): FeedRemovedEventFilter;
+
+    "FeedUpdated(bytes21,uint32,uint24,uint256)"(
+      feedId?: PromiseOrValue<BytesLike> | null,
+      rewardBandValue?: null,
+      inflationShare?: null,
+      index?: null
+    ): FeedUpdatedEventFilter;
+    FeedUpdated(
+      feedId?: PromiseOrValue<BytesLike> | null,
+      rewardBandValue?: null,
+      inflationShare?: null,
+      index?: null
+    ): FeedUpdatedEventFilter;
+  };
+
+  estimateGas: {
+    getFeedConfigurations(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getFeedId(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getFeedIds(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getFeedIndex(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getNumberOfFeeds(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getUnusedIndices(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    getFeedConfigurations(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getFeedId(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getFeedIds(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getFeedIndex(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getNumberOfFeeds(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getUnusedIndices(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IFeeCalculator.ts

@@ -0,0 +1,140 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export interface IFeeCalculatorInterface extends utils.Interface {
+  functions: {
+    "calculateFeeByIds(bytes21[])": FunctionFragment;
+    "calculateFeeByIndices(uint256[])": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic: "calculateFeeByIds" | "calculateFeeByIndices"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "calculateFeeByIds",
+    values: [PromiseOrValue<BytesLike>[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "calculateFeeByIndices",
+    values: [PromiseOrValue<BigNumberish>[]]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "calculateFeeByIds",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "calculateFeeByIndices",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface IFeeCalculator extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IFeeCalculatorInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    calculateFeeByIds(
+      _feedIds: PromiseOrValue<BytesLike>[],
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { _fee: BigNumber }>;
+
+    calculateFeeByIndices(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { _fee: BigNumber }>;
+  };
+
+  calculateFeeByIds(
+    _feedIds: PromiseOrValue<BytesLike>[],
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  calculateFeeByIndices(
+    _indices: PromiseOrValue<BigNumberish>[],
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  callStatic: {
+    calculateFeeByIds(
+      _feedIds: PromiseOrValue<BytesLike>[],
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    calculateFeeByIndices(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    calculateFeeByIds(
+      _feedIds: PromiseOrValue<BytesLike>[],
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    calculateFeeByIndices(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    calculateFeeByIds(
+      _feedIds: PromiseOrValue<BytesLike>[],
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    calculateFeeByIndices(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IFlareAssetRegistry.ts

@@ -0,0 +1,450 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export interface IFlareAssetRegistryInterface extends utils.Interface {
+  functions: {
+    "allAssetTypes()": FunctionFragment;
+    "allAssets()": FunctionFragment;
+    "allAssetsOfType(bytes32)": FunctionFragment;
+    "allAssetsOfTypeWithSymbols(bytes32)": FunctionFragment;
+    "allAssetsWithSymbols()": FunctionFragment;
+    "assetBySymbol(string)": FunctionFragment;
+    "assetType(address)": FunctionFragment;
+    "getAttribute(address,bytes32)": FunctionFragment;
+    "incentivePoolFor(address)": FunctionFragment;
+    "isFlareAsset(address)": FunctionFragment;
+    "maxDelegatesByPercent(address)": FunctionFragment;
+    "supportsFtsoDelegation(address)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "allAssetTypes"
+      | "allAssets"
+      | "allAssetsOfType"
+      | "allAssetsOfTypeWithSymbols"
+      | "allAssetsWithSymbols"
+      | "assetBySymbol"
+      | "assetType"
+      | "getAttribute"
+      | "incentivePoolFor"
+      | "isFlareAsset"
+      | "maxDelegatesByPercent"
+      | "supportsFtsoDelegation"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "allAssetTypes",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "allAssets", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "allAssetsOfType",
+    values: [PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "allAssetsOfTypeWithSymbols",
+    values: [PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "allAssetsWithSymbols",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "assetBySymbol",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "assetType",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getAttribute",
+    values: [PromiseOrValue<string>, PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "incentivePoolFor",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isFlareAsset",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "maxDelegatesByPercent",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "supportsFtsoDelegation",
+    values: [PromiseOrValue<string>]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "allAssetTypes",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "allAssets", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "allAssetsOfType",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "allAssetsOfTypeWithSymbols",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "allAssetsWithSymbols",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "assetBySymbol",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "assetType", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getAttribute",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "incentivePoolFor",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "isFlareAsset",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "maxDelegatesByPercent",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "supportsFtsoDelegation",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface IFlareAssetRegistry extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IFlareAssetRegistryInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    allAssetTypes(overrides?: CallOverrides): Promise<[string[]]>;
+
+    allAssets(overrides?: CallOverrides): Promise<[string[]]>;
+
+    allAssetsOfType(
+      _assetType: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[string[]]>;
+
+    allAssetsOfTypeWithSymbols(
+      _assetType: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[string[], string[]]>;
+
+    allAssetsWithSymbols(
+      overrides?: CallOverrides
+    ): Promise<[string[], string[]]>;
+
+    assetBySymbol(
+      symbol: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[string]>;
+
+    assetType(
+      _token: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[string]>;
+
+    getAttribute(
+      token: PromiseOrValue<string>,
+      nameHash: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[boolean, string] & { defined: boolean; value: string }>;
+
+    incentivePoolFor(
+      token: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[string]>;
+
+    isFlareAsset(
+      token: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[boolean]>;
+
+    maxDelegatesByPercent(
+      token: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    supportsFtsoDelegation(
+      token: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[boolean]>;
+  };
+
+  allAssetTypes(overrides?: CallOverrides): Promise<string[]>;
+
+  allAssets(overrides?: CallOverrides): Promise<string[]>;
+
+  allAssetsOfType(
+    _assetType: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<string[]>;
+
+  allAssetsOfTypeWithSymbols(
+    _assetType: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<[string[], string[]]>;
+
+  allAssetsWithSymbols(
+    overrides?: CallOverrides
+  ): Promise<[string[], string[]]>;
+
+  assetBySymbol(
+    symbol: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  assetType(
+    _token: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  getAttribute(
+    token: PromiseOrValue<string>,
+    nameHash: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<[boolean, string] & { defined: boolean; value: string }>;
+
+  incentivePoolFor(
+    token: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  isFlareAsset(
+    token: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<boolean>;
+
+  maxDelegatesByPercent(
+    token: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  supportsFtsoDelegation(
+    token: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<boolean>;
+
+  callStatic: {
+    allAssetTypes(overrides?: CallOverrides): Promise<string[]>;
+
+    allAssets(overrides?: CallOverrides): Promise<string[]>;
+
+    allAssetsOfType(
+      _assetType: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<string[]>;
+
+    allAssetsOfTypeWithSymbols(
+      _assetType: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[string[], string[]]>;
+
+    allAssetsWithSymbols(
+      overrides?: CallOverrides
+    ): Promise<[string[], string[]]>;
+
+    assetBySymbol(
+      symbol: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    assetType(
+      _token: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    getAttribute(
+      token: PromiseOrValue<string>,
+      nameHash: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[boolean, string] & { defined: boolean; value: string }>;
+
+    incentivePoolFor(
+      token: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    isFlareAsset(
+      token: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    maxDelegatesByPercent(
+      token: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    supportsFtsoDelegation(
+      token: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    allAssetTypes(overrides?: CallOverrides): Promise<BigNumber>;
+
+    allAssets(overrides?: CallOverrides): Promise<BigNumber>;
+
+    allAssetsOfType(
+      _assetType: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    allAssetsOfTypeWithSymbols(
+      _assetType: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    allAssetsWithSymbols(overrides?: CallOverrides): Promise<BigNumber>;
+
+    assetBySymbol(
+      symbol: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    assetType(
+      _token: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getAttribute(
+      token: PromiseOrValue<string>,
+      nameHash: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    incentivePoolFor(
+      token: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    isFlareAsset(
+      token: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    maxDelegatesByPercent(
+      token: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    supportsFtsoDelegation(
+      token: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    allAssetTypes(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    allAssets(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    allAssetsOfType(
+      _assetType: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    allAssetsOfTypeWithSymbols(
+      _assetType: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    allAssetsWithSymbols(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    assetBySymbol(
+      symbol: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    assetType(
+      _token: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getAttribute(
+      token: PromiseOrValue<string>,
+      nameHash: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    incentivePoolFor(
+      token: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    isFlareAsset(
+      token: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    maxDelegatesByPercent(
+      token: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    supportsFtsoDelegation(
+      token: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IFlareContractRegistry.ts

@@ -0,0 +1,241 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export interface IFlareContractRegistryInterface extends utils.Interface {
+  functions: {
+    "getAllContracts()": FunctionFragment;
+    "getContractAddressByHash(bytes32)": FunctionFragment;
+    "getContractAddressByName(string)": FunctionFragment;
+    "getContractAddressesByHash(bytes32[])": FunctionFragment;
+    "getContractAddressesByName(string[])": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "getAllContracts"
+      | "getContractAddressByHash"
+      | "getContractAddressByName"
+      | "getContractAddressesByHash"
+      | "getContractAddressesByName"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "getAllContracts",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getContractAddressByHash",
+    values: [PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getContractAddressByName",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getContractAddressesByHash",
+    values: [PromiseOrValue<BytesLike>[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getContractAddressesByName",
+    values: [PromiseOrValue<string>[]]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "getAllContracts",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getContractAddressByHash",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getContractAddressByName",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getContractAddressesByHash",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getContractAddressesByName",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface IFlareContractRegistry extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IFlareContractRegistryInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    getAllContracts(
+      overrides?: CallOverrides
+    ): Promise<
+      [string[], string[]] & { _names: string[]; _addresses: string[] }
+    >;
+
+    getContractAddressByHash(
+      _nameHash: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[string]>;
+
+    getContractAddressByName(
+      _name: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[string]>;
+
+    getContractAddressesByHash(
+      _nameHashes: PromiseOrValue<BytesLike>[],
+      overrides?: CallOverrides
+    ): Promise<[string[]]>;
+
+    getContractAddressesByName(
+      _names: PromiseOrValue<string>[],
+      overrides?: CallOverrides
+    ): Promise<[string[]]>;
+  };
+
+  getAllContracts(
+    overrides?: CallOverrides
+  ): Promise<[string[], string[]] & { _names: string[]; _addresses: string[] }>;
+
+  getContractAddressByHash(
+    _nameHash: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  getContractAddressByName(
+    _name: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  getContractAddressesByHash(
+    _nameHashes: PromiseOrValue<BytesLike>[],
+    overrides?: CallOverrides
+  ): Promise<string[]>;
+
+  getContractAddressesByName(
+    _names: PromiseOrValue<string>[],
+    overrides?: CallOverrides
+  ): Promise<string[]>;
+
+  callStatic: {
+    getAllContracts(
+      overrides?: CallOverrides
+    ): Promise<
+      [string[], string[]] & { _names: string[]; _addresses: string[] }
+    >;
+
+    getContractAddressByHash(
+      _nameHash: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    getContractAddressByName(
+      _name: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    getContractAddressesByHash(
+      _nameHashes: PromiseOrValue<BytesLike>[],
+      overrides?: CallOverrides
+    ): Promise<string[]>;
+
+    getContractAddressesByName(
+      _names: PromiseOrValue<string>[],
+      overrides?: CallOverrides
+    ): Promise<string[]>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    getAllContracts(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getContractAddressByHash(
+      _nameHash: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getContractAddressByName(
+      _name: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getContractAddressesByHash(
+      _nameHashes: PromiseOrValue<BytesLike>[],
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getContractAddressesByName(
+      _names: PromiseOrValue<string>[],
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    getAllContracts(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getContractAddressByHash(
+      _nameHash: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getContractAddressByName(
+      _name: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getContractAddressesByHash(
+      _nameHashes: PromiseOrValue<BytesLike>[],
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getContractAddressesByName(
+      _names: PromiseOrValue<string>[],
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IFlareSystemsCalculator.ts

@@ -0,0 +1,226 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export interface IFlareSystemsCalculatorInterface extends utils.Interface {
+  functions: {
+    "signingPolicySignNoRewardsDurationBlocks()": FunctionFragment;
+    "signingPolicySignNonPunishableDurationBlocks()": FunctionFragment;
+    "signingPolicySignNonPunishableDurationSeconds()": FunctionFragment;
+    "wNatCapPPM()": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "signingPolicySignNoRewardsDurationBlocks"
+      | "signingPolicySignNonPunishableDurationBlocks"
+      | "signingPolicySignNonPunishableDurationSeconds"
+      | "wNatCapPPM"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "signingPolicySignNoRewardsDurationBlocks",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "signingPolicySignNonPunishableDurationBlocks",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "signingPolicySignNonPunishableDurationSeconds",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "wNatCapPPM",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "signingPolicySignNoRewardsDurationBlocks",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "signingPolicySignNonPunishableDurationBlocks",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "signingPolicySignNonPunishableDurationSeconds",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "wNatCapPPM", data: BytesLike): Result;
+
+  events: {
+    "VoterRegistrationInfo(address,uint24,address,uint16,uint256,uint256,bytes20[],uint256[])": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "VoterRegistrationInfo"): EventFragment;
+}
+
+export interface VoterRegistrationInfoEventObject {
+  voter: string;
+  rewardEpochId: number;
+  delegationAddress: string;
+  delegationFeeBIPS: number;
+  wNatWeight: BigNumber;
+  wNatCappedWeight: BigNumber;
+  nodeIds: string[];
+  nodeWeights: BigNumber[];
+}
+export type VoterRegistrationInfoEvent = TypedEvent<
+  [string, number, string, number, BigNumber, BigNumber, string[], BigNumber[]],
+  VoterRegistrationInfoEventObject
+>;
+
+export type VoterRegistrationInfoEventFilter =
+  TypedEventFilter<VoterRegistrationInfoEvent>;
+
+export interface IFlareSystemsCalculator extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IFlareSystemsCalculatorInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    signingPolicySignNoRewardsDurationBlocks(
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    signingPolicySignNonPunishableDurationBlocks(
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    signingPolicySignNonPunishableDurationSeconds(
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    wNatCapPPM(overrides?: CallOverrides): Promise<[number]>;
+  };
+
+  signingPolicySignNoRewardsDurationBlocks(
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  signingPolicySignNonPunishableDurationBlocks(
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  signingPolicySignNonPunishableDurationSeconds(
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  wNatCapPPM(overrides?: CallOverrides): Promise<number>;
+
+  callStatic: {
+    signingPolicySignNoRewardsDurationBlocks(
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    signingPolicySignNonPunishableDurationBlocks(
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    signingPolicySignNonPunishableDurationSeconds(
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    wNatCapPPM(overrides?: CallOverrides): Promise<number>;
+  };
+
+  filters: {
+    "VoterRegistrationInfo(address,uint24,address,uint16,uint256,uint256,bytes20[],uint256[])"(
+      voter?: PromiseOrValue<string> | null,
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      delegationAddress?: null,
+      delegationFeeBIPS?: null,
+      wNatWeight?: null,
+      wNatCappedWeight?: null,
+      nodeIds?: null,
+      nodeWeights?: null
+    ): VoterRegistrationInfoEventFilter;
+    VoterRegistrationInfo(
+      voter?: PromiseOrValue<string> | null,
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      delegationAddress?: null,
+      delegationFeeBIPS?: null,
+      wNatWeight?: null,
+      wNatCappedWeight?: null,
+      nodeIds?: null,
+      nodeWeights?: null
+    ): VoterRegistrationInfoEventFilter;
+  };
+
+  estimateGas: {
+    signingPolicySignNoRewardsDurationBlocks(
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    signingPolicySignNonPunishableDurationBlocks(
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    signingPolicySignNonPunishableDurationSeconds(
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    wNatCapPPM(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    signingPolicySignNoRewardsDurationBlocks(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    signingPolicySignNonPunishableDurationBlocks(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    signingPolicySignNonPunishableDurationSeconds(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    wNatCapPPM(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IFlareSystemsManager.ts

@@ -0,0 +1,902 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export declare namespace IFlareSystemsManager {
+  export type NumberOfWeightBasedClaimsStruct = {
+    rewardManagerId: PromiseOrValue<BigNumberish>;
+    noOfWeightBasedClaims: PromiseOrValue<BigNumberish>;
+  };
+
+  export type NumberOfWeightBasedClaimsStructOutput = [BigNumber, BigNumber] & {
+    rewardManagerId: BigNumber;
+    noOfWeightBasedClaims: BigNumber;
+  };
+
+  export type SignatureStruct = {
+    v: PromiseOrValue<BigNumberish>;
+    r: PromiseOrValue<BytesLike>;
+    s: PromiseOrValue<BytesLike>;
+  };
+
+  export type SignatureStructOutput = [number, string, string] & {
+    v: number;
+    r: string;
+    s: string;
+  };
+}
+
+export interface IFlareSystemsManagerInterface extends utils.Interface {
+  functions: {
+    "firstRewardEpochStartTs()": FunctionFragment;
+    "firstVotingRoundStartTs()": FunctionFragment;
+    "getCurrentRewardEpoch()": FunctionFragment;
+    "getCurrentRewardEpochId()": FunctionFragment;
+    "getCurrentVotingEpochId()": FunctionFragment;
+    "getSeed(uint256)": FunctionFragment;
+    "getStartVotingRoundId(uint256)": FunctionFragment;
+    "getThreshold(uint256)": FunctionFragment;
+    "getVotePowerBlock(uint256)": FunctionFragment;
+    "getVoterRegistrationData(uint256)": FunctionFragment;
+    "isVoterRegistrationEnabled()": FunctionFragment;
+    "rewardEpochDurationSeconds()": FunctionFragment;
+    "signNewSigningPolicy(uint24,bytes32,(uint8,bytes32,bytes32))": FunctionFragment;
+    "signRewards(uint24,(uint256,uint256)[],bytes32,(uint8,bytes32,bytes32))": FunctionFragment;
+    "signUptimeVote(uint24,bytes32,(uint8,bytes32,bytes32))": FunctionFragment;
+    "submitUptimeVote(uint24,bytes20[],(uint8,bytes32,bytes32))": FunctionFragment;
+    "votingEpochDurationSeconds()": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "firstRewardEpochStartTs"
+      | "firstVotingRoundStartTs"
+      | "getCurrentRewardEpoch"
+      | "getCurrentRewardEpochId"
+      | "getCurrentVotingEpochId"
+      | "getSeed"
+      | "getStartVotingRoundId"
+      | "getThreshold"
+      | "getVotePowerBlock"
+      | "getVoterRegistrationData"
+      | "isVoterRegistrationEnabled"
+      | "rewardEpochDurationSeconds"
+      | "signNewSigningPolicy"
+      | "signRewards"
+      | "signUptimeVote"
+      | "submitUptimeVote"
+      | "votingEpochDurationSeconds"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "firstRewardEpochStartTs",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "firstVotingRoundStartTs",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentRewardEpoch",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentRewardEpochId",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentVotingEpochId",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getSeed",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getStartVotingRoundId",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getThreshold",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getVotePowerBlock",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getVoterRegistrationData",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isVoterRegistrationEnabled",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "rewardEpochDurationSeconds",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "signNewSigningPolicy",
+    values: [
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BytesLike>,
+      IFlareSystemsManager.SignatureStruct
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "signRewards",
+    values: [
+      PromiseOrValue<BigNumberish>,
+      IFlareSystemsManager.NumberOfWeightBasedClaimsStruct[],
+      PromiseOrValue<BytesLike>,
+      IFlareSystemsManager.SignatureStruct
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "signUptimeVote",
+    values: [
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BytesLike>,
+      IFlareSystemsManager.SignatureStruct
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "submitUptimeVote",
+    values: [
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BytesLike>[],
+      IFlareSystemsManager.SignatureStruct
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "votingEpochDurationSeconds",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "firstRewardEpochStartTs",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "firstVotingRoundStartTs",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentRewardEpoch",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentRewardEpochId",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentVotingEpochId",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getSeed", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getStartVotingRoundId",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getThreshold",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getVotePowerBlock",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getVoterRegistrationData",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "isVoterRegistrationEnabled",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "rewardEpochDurationSeconds",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "signNewSigningPolicy",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "signRewards",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "signUptimeVote",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "submitUptimeVote",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "votingEpochDurationSeconds",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "RandomAcquisitionStarted(uint24,uint64)": EventFragment;
+    "RewardEpochStarted(uint24,uint32,uint64)": EventFragment;
+    "RewardsSigned(uint24,address,address,bytes32,tuple[],uint64,bool)": EventFragment;
+    "SignUptimeVoteEnabled(uint24,uint64)": EventFragment;
+    "SigningPolicySigned(uint24,address,address,uint64,bool)": EventFragment;
+    "UptimeVoteSigned(uint24,address,address,bytes32,uint64,bool)": EventFragment;
+    "UptimeVoteSubmitted(uint24,address,address,bytes20[],uint64)": EventFragment;
+    "VotePowerBlockSelected(uint24,uint64,uint64)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "RandomAcquisitionStarted"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "RewardEpochStarted"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "RewardsSigned"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "SignUptimeVoteEnabled"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "SigningPolicySigned"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "UptimeVoteSigned"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "UptimeVoteSubmitted"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "VotePowerBlockSelected"): EventFragment;
+}
+
+export interface RandomAcquisitionStartedEventObject {
+  rewardEpochId: number;
+  timestamp: BigNumber;
+}
+export type RandomAcquisitionStartedEvent = TypedEvent<
+  [number, BigNumber],
+  RandomAcquisitionStartedEventObject
+>;
+
+export type RandomAcquisitionStartedEventFilter =
+  TypedEventFilter<RandomAcquisitionStartedEvent>;
+
+export interface RewardEpochStartedEventObject {
+  rewardEpochId: number;
+  startVotingRoundId: number;
+  timestamp: BigNumber;
+}
+export type RewardEpochStartedEvent = TypedEvent<
+  [number, number, BigNumber],
+  RewardEpochStartedEventObject
+>;
+
+export type RewardEpochStartedEventFilter =
+  TypedEventFilter<RewardEpochStartedEvent>;
+
+export interface RewardsSignedEventObject {
+  rewardEpochId: number;
+  signingPolicyAddress: string;
+  voter: string;
+  rewardsHash: string;
+  noOfWeightBasedClaims: IFlareSystemsManager.NumberOfWeightBasedClaimsStructOutput[];
+  timestamp: BigNumber;
+  thresholdReached: boolean;
+}
+export type RewardsSignedEvent = TypedEvent<
+  [
+    number,
+    string,
+    string,
+    string,
+    IFlareSystemsManager.NumberOfWeightBasedClaimsStructOutput[],
+    BigNumber,
+    boolean
+  ],
+  RewardsSignedEventObject
+>;
+
+export type RewardsSignedEventFilter = TypedEventFilter<RewardsSignedEvent>;
+
+export interface SignUptimeVoteEnabledEventObject {
+  rewardEpochId: number;
+  timestamp: BigNumber;
+}
+export type SignUptimeVoteEnabledEvent = TypedEvent<
+  [number, BigNumber],
+  SignUptimeVoteEnabledEventObject
+>;
+
+export type SignUptimeVoteEnabledEventFilter =
+  TypedEventFilter<SignUptimeVoteEnabledEvent>;
+
+export interface SigningPolicySignedEventObject {
+  rewardEpochId: number;
+  signingPolicyAddress: string;
+  voter: string;
+  timestamp: BigNumber;
+  thresholdReached: boolean;
+}
+export type SigningPolicySignedEvent = TypedEvent<
+  [number, string, string, BigNumber, boolean],
+  SigningPolicySignedEventObject
+>;
+
+export type SigningPolicySignedEventFilter =
+  TypedEventFilter<SigningPolicySignedEvent>;
+
+export interface UptimeVoteSignedEventObject {
+  rewardEpochId: number;
+  signingPolicyAddress: string;
+  voter: string;
+  uptimeVoteHash: string;
+  timestamp: BigNumber;
+  thresholdReached: boolean;
+}
+export type UptimeVoteSignedEvent = TypedEvent<
+  [number, string, string, string, BigNumber, boolean],
+  UptimeVoteSignedEventObject
+>;
+
+export type UptimeVoteSignedEventFilter =
+  TypedEventFilter<UptimeVoteSignedEvent>;
+
+export interface UptimeVoteSubmittedEventObject {
+  rewardEpochId: number;
+  signingPolicyAddress: string;
+  voter: string;
+  nodeIds: string[];
+  timestamp: BigNumber;
+}
+export type UptimeVoteSubmittedEvent = TypedEvent<
+  [number, string, string, string[], BigNumber],
+  UptimeVoteSubmittedEventObject
+>;
+
+export type UptimeVoteSubmittedEventFilter =
+  TypedEventFilter<UptimeVoteSubmittedEvent>;
+
+export interface VotePowerBlockSelectedEventObject {
+  rewardEpochId: number;
+  votePowerBlock: BigNumber;
+  timestamp: BigNumber;
+}
+export type VotePowerBlockSelectedEvent = TypedEvent<
+  [number, BigNumber, BigNumber],
+  VotePowerBlockSelectedEventObject
+>;
+
+export type VotePowerBlockSelectedEventFilter =
+  TypedEventFilter<VotePowerBlockSelectedEvent>;
+
+export interface IFlareSystemsManager extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IFlareSystemsManagerInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    firstRewardEpochStartTs(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    firstVotingRoundStartTs(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    getCurrentRewardEpoch(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    getCurrentRewardEpochId(overrides?: CallOverrides): Promise<[number]>;
+
+    getCurrentVotingEpochId(overrides?: CallOverrides): Promise<[number]>;
+
+    getSeed(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    getStartVotingRoundId(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[number]>;
+
+    getThreshold(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[number]>;
+
+    getVotePowerBlock(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { _votePowerBlock: BigNumber }>;
+
+    getVoterRegistrationData(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, boolean] & { _votePowerBlock: BigNumber; _enabled: boolean }
+    >;
+
+    isVoterRegistrationEnabled(overrides?: CallOverrides): Promise<[boolean]>;
+
+    rewardEpochDurationSeconds(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    signNewSigningPolicy(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _newSigningPolicyHash: PromiseOrValue<BytesLike>,
+      _signature: IFlareSystemsManager.SignatureStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    signRewards(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _noOfWeightBasedClaims: IFlareSystemsManager.NumberOfWeightBasedClaimsStruct[],
+      _rewardsHash: PromiseOrValue<BytesLike>,
+      _signature: IFlareSystemsManager.SignatureStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    signUptimeVote(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _uptimeVoteHash: PromiseOrValue<BytesLike>,
+      _signature: IFlareSystemsManager.SignatureStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    submitUptimeVote(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _nodeIds: PromiseOrValue<BytesLike>[],
+      _signature: IFlareSystemsManager.SignatureStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    votingEpochDurationSeconds(overrides?: CallOverrides): Promise<[BigNumber]>;
+  };
+
+  firstRewardEpochStartTs(overrides?: CallOverrides): Promise<BigNumber>;
+
+  firstVotingRoundStartTs(overrides?: CallOverrides): Promise<BigNumber>;
+
+  getCurrentRewardEpoch(overrides?: CallOverrides): Promise<BigNumber>;
+
+  getCurrentRewardEpochId(overrides?: CallOverrides): Promise<number>;
+
+  getCurrentVotingEpochId(overrides?: CallOverrides): Promise<number>;
+
+  getSeed(
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  getStartVotingRoundId(
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<number>;
+
+  getThreshold(
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<number>;
+
+  getVotePowerBlock(
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  getVoterRegistrationData(
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, boolean] & { _votePowerBlock: BigNumber; _enabled: boolean }
+  >;
+
+  isVoterRegistrationEnabled(overrides?: CallOverrides): Promise<boolean>;
+
+  rewardEpochDurationSeconds(overrides?: CallOverrides): Promise<BigNumber>;
+
+  signNewSigningPolicy(
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    _newSigningPolicyHash: PromiseOrValue<BytesLike>,
+    _signature: IFlareSystemsManager.SignatureStruct,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  signRewards(
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    _noOfWeightBasedClaims: IFlareSystemsManager.NumberOfWeightBasedClaimsStruct[],
+    _rewardsHash: PromiseOrValue<BytesLike>,
+    _signature: IFlareSystemsManager.SignatureStruct,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  signUptimeVote(
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    _uptimeVoteHash: PromiseOrValue<BytesLike>,
+    _signature: IFlareSystemsManager.SignatureStruct,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  submitUptimeVote(
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    _nodeIds: PromiseOrValue<BytesLike>[],
+    _signature: IFlareSystemsManager.SignatureStruct,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  votingEpochDurationSeconds(overrides?: CallOverrides): Promise<BigNumber>;
+
+  callStatic: {
+    firstRewardEpochStartTs(overrides?: CallOverrides): Promise<BigNumber>;
+
+    firstVotingRoundStartTs(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentRewardEpoch(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentRewardEpochId(overrides?: CallOverrides): Promise<number>;
+
+    getCurrentVotingEpochId(overrides?: CallOverrides): Promise<number>;
+
+    getSeed(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getStartVotingRoundId(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<number>;
+
+    getThreshold(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<number>;
+
+    getVotePowerBlock(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getVoterRegistrationData(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, boolean] & { _votePowerBlock: BigNumber; _enabled: boolean }
+    >;
+
+    isVoterRegistrationEnabled(overrides?: CallOverrides): Promise<boolean>;
+
+    rewardEpochDurationSeconds(overrides?: CallOverrides): Promise<BigNumber>;
+
+    signNewSigningPolicy(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _newSigningPolicyHash: PromiseOrValue<BytesLike>,
+      _signature: IFlareSystemsManager.SignatureStruct,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    signRewards(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _noOfWeightBasedClaims: IFlareSystemsManager.NumberOfWeightBasedClaimsStruct[],
+      _rewardsHash: PromiseOrValue<BytesLike>,
+      _signature: IFlareSystemsManager.SignatureStruct,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    signUptimeVote(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _uptimeVoteHash: PromiseOrValue<BytesLike>,
+      _signature: IFlareSystemsManager.SignatureStruct,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    submitUptimeVote(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _nodeIds: PromiseOrValue<BytesLike>[],
+      _signature: IFlareSystemsManager.SignatureStruct,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    votingEpochDurationSeconds(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  filters: {
+    "RandomAcquisitionStarted(uint24,uint64)"(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      timestamp?: null
+    ): RandomAcquisitionStartedEventFilter;
+    RandomAcquisitionStarted(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      timestamp?: null
+    ): RandomAcquisitionStartedEventFilter;
+
+    "RewardEpochStarted(uint24,uint32,uint64)"(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      startVotingRoundId?: null,
+      timestamp?: null
+    ): RewardEpochStartedEventFilter;
+    RewardEpochStarted(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      startVotingRoundId?: null,
+      timestamp?: null
+    ): RewardEpochStartedEventFilter;
+
+    "RewardsSigned(uint24,address,address,bytes32,tuple[],uint64,bool)"(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      signingPolicyAddress?: PromiseOrValue<string> | null,
+      voter?: PromiseOrValue<string> | null,
+      rewardsHash?: null,
+      noOfWeightBasedClaims?: null,
+      timestamp?: null,
+      thresholdReached?: null
+    ): RewardsSignedEventFilter;
+    RewardsSigned(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      signingPolicyAddress?: PromiseOrValue<string> | null,
+      voter?: PromiseOrValue<string> | null,
+      rewardsHash?: null,
+      noOfWeightBasedClaims?: null,
+      timestamp?: null,
+      thresholdReached?: null
+    ): RewardsSignedEventFilter;
+
+    "SignUptimeVoteEnabled(uint24,uint64)"(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      timestamp?: null
+    ): SignUptimeVoteEnabledEventFilter;
+    SignUptimeVoteEnabled(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      timestamp?: null
+    ): SignUptimeVoteEnabledEventFilter;
+
+    "SigningPolicySigned(uint24,address,address,uint64,bool)"(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      signingPolicyAddress?: PromiseOrValue<string> | null,
+      voter?: PromiseOrValue<string> | null,
+      timestamp?: null,
+      thresholdReached?: null
+    ): SigningPolicySignedEventFilter;
+    SigningPolicySigned(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      signingPolicyAddress?: PromiseOrValue<string> | null,
+      voter?: PromiseOrValue<string> | null,
+      timestamp?: null,
+      thresholdReached?: null
+    ): SigningPolicySignedEventFilter;
+
+    "UptimeVoteSigned(uint24,address,address,bytes32,uint64,bool)"(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      signingPolicyAddress?: PromiseOrValue<string> | null,
+      voter?: PromiseOrValue<string> | null,
+      uptimeVoteHash?: null,
+      timestamp?: null,
+      thresholdReached?: null
+    ): UptimeVoteSignedEventFilter;
+    UptimeVoteSigned(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      signingPolicyAddress?: PromiseOrValue<string> | null,
+      voter?: PromiseOrValue<string> | null,
+      uptimeVoteHash?: null,
+      timestamp?: null,
+      thresholdReached?: null
+    ): UptimeVoteSignedEventFilter;
+
+    "UptimeVoteSubmitted(uint24,address,address,bytes20[],uint64)"(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      signingPolicyAddress?: PromiseOrValue<string> | null,
+      voter?: PromiseOrValue<string> | null,
+      nodeIds?: null,
+      timestamp?: null
+    ): UptimeVoteSubmittedEventFilter;
+    UptimeVoteSubmitted(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      signingPolicyAddress?: PromiseOrValue<string> | null,
+      voter?: PromiseOrValue<string> | null,
+      nodeIds?: null,
+      timestamp?: null
+    ): UptimeVoteSubmittedEventFilter;
+
+    "VotePowerBlockSelected(uint24,uint64,uint64)"(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      votePowerBlock?: null,
+      timestamp?: null
+    ): VotePowerBlockSelectedEventFilter;
+    VotePowerBlockSelected(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      votePowerBlock?: null,
+      timestamp?: null
+    ): VotePowerBlockSelectedEventFilter;
+  };
+
+  estimateGas: {
+    firstRewardEpochStartTs(overrides?: CallOverrides): Promise<BigNumber>;
+
+    firstVotingRoundStartTs(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentRewardEpoch(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentRewardEpochId(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentVotingEpochId(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getSeed(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getStartVotingRoundId(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getThreshold(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getVotePowerBlock(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getVoterRegistrationData(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    isVoterRegistrationEnabled(overrides?: CallOverrides): Promise<BigNumber>;
+
+    rewardEpochDurationSeconds(overrides?: CallOverrides): Promise<BigNumber>;
+
+    signNewSigningPolicy(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _newSigningPolicyHash: PromiseOrValue<BytesLike>,
+      _signature: IFlareSystemsManager.SignatureStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    signRewards(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _noOfWeightBasedClaims: IFlareSystemsManager.NumberOfWeightBasedClaimsStruct[],
+      _rewardsHash: PromiseOrValue<BytesLike>,
+      _signature: IFlareSystemsManager.SignatureStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    signUptimeVote(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _uptimeVoteHash: PromiseOrValue<BytesLike>,
+      _signature: IFlareSystemsManager.SignatureStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    submitUptimeVote(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _nodeIds: PromiseOrValue<BytesLike>[],
+      _signature: IFlareSystemsManager.SignatureStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    votingEpochDurationSeconds(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    firstRewardEpochStartTs(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    firstVotingRoundStartTs(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getCurrentRewardEpoch(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getCurrentRewardEpochId(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getCurrentVotingEpochId(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getSeed(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getStartVotingRoundId(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getThreshold(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getVotePowerBlock(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getVoterRegistrationData(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    isVoterRegistrationEnabled(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    rewardEpochDurationSeconds(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    signNewSigningPolicy(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _newSigningPolicyHash: PromiseOrValue<BytesLike>,
+      _signature: IFlareSystemsManager.SignatureStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    signRewards(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _noOfWeightBasedClaims: IFlareSystemsManager.NumberOfWeightBasedClaimsStruct[],
+      _rewardsHash: PromiseOrValue<BytesLike>,
+      _signature: IFlareSystemsManager.SignatureStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    signUptimeVote(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _uptimeVoteHash: PromiseOrValue<BytesLike>,
+      _signature: IFlareSystemsManager.SignatureStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    submitUptimeVote(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _nodeIds: PromiseOrValue<BytesLike>[],
+      _signature: IFlareSystemsManager.SignatureStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    votingEpochDurationSeconds(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IFtso.ts

@@ -0,0 +1,738 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export interface IFtsoInterface extends utils.Interface {
+  functions: {
+    "active()": FunctionFragment;
+    "getCurrentEpochId()": FunctionFragment;
+    "getCurrentPrice()": FunctionFragment;
+    "getCurrentPriceDetails()": FunctionFragment;
+    "getCurrentPriceFromTrustedProviders()": FunctionFragment;
+    "getCurrentPriceWithDecimals()": FunctionFragment;
+    "getCurrentPriceWithDecimalsFromTrustedProviders()": FunctionFragment;
+    "getCurrentRandom()": FunctionFragment;
+    "getEpochId(uint256)": FunctionFragment;
+    "getEpochPrice(uint256)": FunctionFragment;
+    "getEpochPriceForVoter(uint256,address)": FunctionFragment;
+    "getPriceEpochConfiguration()": FunctionFragment;
+    "getPriceEpochData()": FunctionFragment;
+    "getRandom(uint256)": FunctionFragment;
+    "symbol()": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "active"
+      | "getCurrentEpochId"
+      | "getCurrentPrice"
+      | "getCurrentPriceDetails"
+      | "getCurrentPriceFromTrustedProviders"
+      | "getCurrentPriceWithDecimals"
+      | "getCurrentPriceWithDecimalsFromTrustedProviders"
+      | "getCurrentRandom"
+      | "getEpochId"
+      | "getEpochPrice"
+      | "getEpochPriceForVoter"
+      | "getPriceEpochConfiguration"
+      | "getPriceEpochData"
+      | "getRandom"
+      | "symbol"
+  ): FunctionFragment;
+
+  encodeFunctionData(functionFragment: "active", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentEpochId",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentPrice",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentPriceDetails",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentPriceFromTrustedProviders",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentPriceWithDecimals",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentPriceWithDecimalsFromTrustedProviders",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentRandom",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getEpochId",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getEpochPrice",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getEpochPriceForVoter",
+    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getPriceEpochConfiguration",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getPriceEpochData",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRandom",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
+
+  decodeFunctionResult(functionFragment: "active", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentEpochId",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentPrice",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentPriceDetails",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentPriceFromTrustedProviders",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentPriceWithDecimals",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentPriceWithDecimalsFromTrustedProviders",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentRandom",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getEpochId", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getEpochPrice",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getEpochPriceForVoter",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getPriceEpochConfiguration",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getPriceEpochData",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getRandom", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
+
+  events: {
+    "LowTurnout(uint256,uint256,uint256,uint256)": EventFragment;
+    "PriceEpochInitializedOnFtso(uint256,uint256,uint256)": EventFragment;
+    "PriceFinalized(uint256,uint256,bool,uint256,uint256,uint256,uint256,uint8,uint256)": EventFragment;
+    "PriceRevealed(address,uint256,uint256,uint256,uint256,uint256)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "LowTurnout"): EventFragment;
+  getEvent(
+    nameOrSignatureOrTopic: "PriceEpochInitializedOnFtso"
+  ): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "PriceFinalized"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "PriceRevealed"): EventFragment;
+}
+
+export interface LowTurnoutEventObject {
+  epochId: BigNumber;
+  natTurnout: BigNumber;
+  lowNatTurnoutThresholdBIPS: BigNumber;
+  timestamp: BigNumber;
+}
+export type LowTurnoutEvent = TypedEvent<
+  [BigNumber, BigNumber, BigNumber, BigNumber],
+  LowTurnoutEventObject
+>;
+
+export type LowTurnoutEventFilter = TypedEventFilter<LowTurnoutEvent>;
+
+export interface PriceEpochInitializedOnFtsoEventObject {
+  epochId: BigNumber;
+  endTime: BigNumber;
+  timestamp: BigNumber;
+}
+export type PriceEpochInitializedOnFtsoEvent = TypedEvent<
+  [BigNumber, BigNumber, BigNumber],
+  PriceEpochInitializedOnFtsoEventObject
+>;
+
+export type PriceEpochInitializedOnFtsoEventFilter =
+  TypedEventFilter<PriceEpochInitializedOnFtsoEvent>;
+
+export interface PriceFinalizedEventObject {
+  epochId: BigNumber;
+  price: BigNumber;
+  rewardedFtso: boolean;
+  lowIQRRewardPrice: BigNumber;
+  highIQRRewardPrice: BigNumber;
+  lowElasticBandRewardPrice: BigNumber;
+  highElasticBandRewardPrice: BigNumber;
+  finalizationType: number;
+  timestamp: BigNumber;
+}
+export type PriceFinalizedEvent = TypedEvent<
+  [
+    BigNumber,
+    BigNumber,
+    boolean,
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    number,
+    BigNumber
+  ],
+  PriceFinalizedEventObject
+>;
+
+export type PriceFinalizedEventFilter = TypedEventFilter<PriceFinalizedEvent>;
+
+export interface PriceRevealedEventObject {
+  voter: string;
+  epochId: BigNumber;
+  price: BigNumber;
+  timestamp: BigNumber;
+  votePowerNat: BigNumber;
+  votePowerAsset: BigNumber;
+}
+export type PriceRevealedEvent = TypedEvent<
+  [string, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber],
+  PriceRevealedEventObject
+>;
+
+export type PriceRevealedEventFilter = TypedEventFilter<PriceRevealedEvent>;
+
+export interface IFtso extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IFtsoInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    active(overrides?: CallOverrides): Promise<[boolean]>;
+
+    getCurrentEpochId(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    getCurrentPrice(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { _price: BigNumber; _timestamp: BigNumber }
+    >;
+
+    getCurrentPriceDetails(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, number, BigNumber, number] & {
+        _price: BigNumber;
+        _priceTimestamp: BigNumber;
+        _priceFinalizationType: number;
+        _lastPriceEpochFinalizationTimestamp: BigNumber;
+        _lastPriceEpochFinalizationType: number;
+      }
+    >;
+
+    getCurrentPriceFromTrustedProviders(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { _price: BigNumber; _timestamp: BigNumber }
+    >;
+
+    getCurrentPriceWithDecimals(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber] & {
+        _price: BigNumber;
+        _timestamp: BigNumber;
+        _assetPriceUsdDecimals: BigNumber;
+      }
+    >;
+
+    getCurrentPriceWithDecimalsFromTrustedProviders(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber] & {
+        _price: BigNumber;
+        _timestamp: BigNumber;
+        _assetPriceUsdDecimals: BigNumber;
+      }
+    >;
+
+    getCurrentRandom(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    getEpochId(
+      _timestamp: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    getEpochPrice(
+      _epochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    getEpochPriceForVoter(
+      _epochId: PromiseOrValue<BigNumberish>,
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    getPriceEpochConfiguration(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber] & {
+        _firstEpochStartTs: BigNumber;
+        _submitPeriodSeconds: BigNumber;
+        _revealPeriodSeconds: BigNumber;
+      }
+    >;
+
+    getPriceEpochData(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber, boolean] & {
+        _epochId: BigNumber;
+        _epochSubmitEndTime: BigNumber;
+        _epochRevealEndTime: BigNumber;
+        _votePowerBlock: BigNumber;
+        _fallbackMode: boolean;
+      }
+    >;
+
+    getRandom(
+      _epochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    symbol(overrides?: CallOverrides): Promise<[string]>;
+  };
+
+  active(overrides?: CallOverrides): Promise<boolean>;
+
+  getCurrentEpochId(overrides?: CallOverrides): Promise<BigNumber>;
+
+  getCurrentPrice(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber] & { _price: BigNumber; _timestamp: BigNumber }
+  >;
+
+  getCurrentPriceDetails(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, number, BigNumber, number] & {
+      _price: BigNumber;
+      _priceTimestamp: BigNumber;
+      _priceFinalizationType: number;
+      _lastPriceEpochFinalizationTimestamp: BigNumber;
+      _lastPriceEpochFinalizationType: number;
+    }
+  >;
+
+  getCurrentPriceFromTrustedProviders(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber] & { _price: BigNumber; _timestamp: BigNumber }
+  >;
+
+  getCurrentPriceWithDecimals(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, BigNumber] & {
+      _price: BigNumber;
+      _timestamp: BigNumber;
+      _assetPriceUsdDecimals: BigNumber;
+    }
+  >;
+
+  getCurrentPriceWithDecimalsFromTrustedProviders(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, BigNumber] & {
+      _price: BigNumber;
+      _timestamp: BigNumber;
+      _assetPriceUsdDecimals: BigNumber;
+    }
+  >;
+
+  getCurrentRandom(overrides?: CallOverrides): Promise<BigNumber>;
+
+  getEpochId(
+    _timestamp: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  getEpochPrice(
+    _epochId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  getEpochPriceForVoter(
+    _epochId: PromiseOrValue<BigNumberish>,
+    _voter: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  getPriceEpochConfiguration(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, BigNumber] & {
+      _firstEpochStartTs: BigNumber;
+      _submitPeriodSeconds: BigNumber;
+      _revealPeriodSeconds: BigNumber;
+    }
+  >;
+
+  getPriceEpochData(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, BigNumber, BigNumber, boolean] & {
+      _epochId: BigNumber;
+      _epochSubmitEndTime: BigNumber;
+      _epochRevealEndTime: BigNumber;
+      _votePowerBlock: BigNumber;
+      _fallbackMode: boolean;
+    }
+  >;
+
+  getRandom(
+    _epochId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  symbol(overrides?: CallOverrides): Promise<string>;
+
+  callStatic: {
+    active(overrides?: CallOverrides): Promise<boolean>;
+
+    getCurrentEpochId(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentPrice(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { _price: BigNumber; _timestamp: BigNumber }
+    >;
+
+    getCurrentPriceDetails(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, number, BigNumber, number] & {
+        _price: BigNumber;
+        _priceTimestamp: BigNumber;
+        _priceFinalizationType: number;
+        _lastPriceEpochFinalizationTimestamp: BigNumber;
+        _lastPriceEpochFinalizationType: number;
+      }
+    >;
+
+    getCurrentPriceFromTrustedProviders(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { _price: BigNumber; _timestamp: BigNumber }
+    >;
+
+    getCurrentPriceWithDecimals(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber] & {
+        _price: BigNumber;
+        _timestamp: BigNumber;
+        _assetPriceUsdDecimals: BigNumber;
+      }
+    >;
+
+    getCurrentPriceWithDecimalsFromTrustedProviders(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber] & {
+        _price: BigNumber;
+        _timestamp: BigNumber;
+        _assetPriceUsdDecimals: BigNumber;
+      }
+    >;
+
+    getCurrentRandom(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getEpochId(
+      _timestamp: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getEpochPrice(
+      _epochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getEpochPriceForVoter(
+      _epochId: PromiseOrValue<BigNumberish>,
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getPriceEpochConfiguration(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber] & {
+        _firstEpochStartTs: BigNumber;
+        _submitPeriodSeconds: BigNumber;
+        _revealPeriodSeconds: BigNumber;
+      }
+    >;
+
+    getPriceEpochData(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber, boolean] & {
+        _epochId: BigNumber;
+        _epochSubmitEndTime: BigNumber;
+        _epochRevealEndTime: BigNumber;
+        _votePowerBlock: BigNumber;
+        _fallbackMode: boolean;
+      }
+    >;
+
+    getRandom(
+      _epochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    symbol(overrides?: CallOverrides): Promise<string>;
+  };
+
+  filters: {
+    "LowTurnout(uint256,uint256,uint256,uint256)"(
+      epochId?: PromiseOrValue<BigNumberish> | null,
+      natTurnout?: null,
+      lowNatTurnoutThresholdBIPS?: null,
+      timestamp?: null
+    ): LowTurnoutEventFilter;
+    LowTurnout(
+      epochId?: PromiseOrValue<BigNumberish> | null,
+      natTurnout?: null,
+      lowNatTurnoutThresholdBIPS?: null,
+      timestamp?: null
+    ): LowTurnoutEventFilter;
+
+    "PriceEpochInitializedOnFtso(uint256,uint256,uint256)"(
+      epochId?: PromiseOrValue<BigNumberish> | null,
+      endTime?: null,
+      timestamp?: null
+    ): PriceEpochInitializedOnFtsoEventFilter;
+    PriceEpochInitializedOnFtso(
+      epochId?: PromiseOrValue<BigNumberish> | null,
+      endTime?: null,
+      timestamp?: null
+    ): PriceEpochInitializedOnFtsoEventFilter;
+
+    "PriceFinalized(uint256,uint256,bool,uint256,uint256,uint256,uint256,uint8,uint256)"(
+      epochId?: PromiseOrValue<BigNumberish> | null,
+      price?: null,
+      rewardedFtso?: null,
+      lowIQRRewardPrice?: null,
+      highIQRRewardPrice?: null,
+      lowElasticBandRewardPrice?: null,
+      highElasticBandRewardPrice?: null,
+      finalizationType?: null,
+      timestamp?: null
+    ): PriceFinalizedEventFilter;
+    PriceFinalized(
+      epochId?: PromiseOrValue<BigNumberish> | null,
+      price?: null,
+      rewardedFtso?: null,
+      lowIQRRewardPrice?: null,
+      highIQRRewardPrice?: null,
+      lowElasticBandRewardPrice?: null,
+      highElasticBandRewardPrice?: null,
+      finalizationType?: null,
+      timestamp?: null
+    ): PriceFinalizedEventFilter;
+
+    "PriceRevealed(address,uint256,uint256,uint256,uint256,uint256)"(
+      voter?: PromiseOrValue<string> | null,
+      epochId?: PromiseOrValue<BigNumberish> | null,
+      price?: null,
+      timestamp?: null,
+      votePowerNat?: null,
+      votePowerAsset?: null
+    ): PriceRevealedEventFilter;
+    PriceRevealed(
+      voter?: PromiseOrValue<string> | null,
+      epochId?: PromiseOrValue<BigNumberish> | null,
+      price?: null,
+      timestamp?: null,
+      votePowerNat?: null,
+      votePowerAsset?: null
+    ): PriceRevealedEventFilter;
+  };
+
+  estimateGas: {
+    active(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentEpochId(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentPrice(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentPriceDetails(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentPriceFromTrustedProviders(
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getCurrentPriceWithDecimals(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentPriceWithDecimalsFromTrustedProviders(
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getCurrentRandom(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getEpochId(
+      _timestamp: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getEpochPrice(
+      _epochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getEpochPriceForVoter(
+      _epochId: PromiseOrValue<BigNumberish>,
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getPriceEpochConfiguration(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getPriceEpochData(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getRandom(
+      _epochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    symbol(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    active(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getCurrentEpochId(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getCurrentPrice(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getCurrentPriceDetails(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getCurrentPriceFromTrustedProviders(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getCurrentPriceWithDecimals(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getCurrentPriceWithDecimalsFromTrustedProviders(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getCurrentRandom(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getEpochId(
+      _timestamp: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getEpochPrice(
+      _epochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getEpochPriceForVoter(
+      _epochId: PromiseOrValue<BigNumberish>,
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getPriceEpochConfiguration(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getPriceEpochData(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getRandom(
+      _epochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    symbol(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IFtsoFeedDecimals.ts

@@ -0,0 +1,348 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export interface IFtsoFeedDecimalsInterface extends utils.Interface {
+  functions: {
+    "decimalsUpdateOffset()": FunctionFragment;
+    "defaultDecimals()": FunctionFragment;
+    "getCurrentDecimals(bytes21)": FunctionFragment;
+    "getCurrentDecimalsBulk(bytes)": FunctionFragment;
+    "getDecimals(bytes21,uint256)": FunctionFragment;
+    "getDecimalsBulk(bytes,uint256)": FunctionFragment;
+    "getScheduledDecimalsChanges(bytes21)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "decimalsUpdateOffset"
+      | "defaultDecimals"
+      | "getCurrentDecimals"
+      | "getCurrentDecimalsBulk"
+      | "getDecimals"
+      | "getDecimalsBulk"
+      | "getScheduledDecimalsChanges"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "decimalsUpdateOffset",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "defaultDecimals",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentDecimals",
+    values: [PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentDecimalsBulk",
+    values: [PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getDecimals",
+    values: [PromiseOrValue<BytesLike>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getDecimalsBulk",
+    values: [PromiseOrValue<BytesLike>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getScheduledDecimalsChanges",
+    values: [PromiseOrValue<BytesLike>]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "decimalsUpdateOffset",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "defaultDecimals",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentDecimals",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentDecimalsBulk",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getDecimals",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getDecimalsBulk",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getScheduledDecimalsChanges",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "DecimalsChanged(bytes21,int8,uint24)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "DecimalsChanged"): EventFragment;
+}
+
+export interface DecimalsChangedEventObject {
+  feedId: string;
+  decimals: number;
+  rewardEpochId: number;
+}
+export type DecimalsChangedEvent = TypedEvent<
+  [string, number, number],
+  DecimalsChangedEventObject
+>;
+
+export type DecimalsChangedEventFilter = TypedEventFilter<DecimalsChangedEvent>;
+
+export interface IFtsoFeedDecimals extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IFtsoFeedDecimalsInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    decimalsUpdateOffset(overrides?: CallOverrides): Promise<[number]>;
+
+    defaultDecimals(overrides?: CallOverrides): Promise<[number]>;
+
+    getCurrentDecimals(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[number]>;
+
+    getCurrentDecimalsBulk(
+      _feedIds: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[string] & { _decimals: string }>;
+
+    getDecimals(
+      _feedId: PromiseOrValue<BytesLike>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[number]>;
+
+    getDecimalsBulk(
+      _feedIds: PromiseOrValue<BytesLike>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[string] & { _decimals: string }>;
+
+    getScheduledDecimalsChanges(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<
+      [number[], BigNumber[], boolean[]] & {
+        _decimals: number[];
+        _validFromEpochId: BigNumber[];
+        _fixed: boolean[];
+      }
+    >;
+  };
+
+  decimalsUpdateOffset(overrides?: CallOverrides): Promise<number>;
+
+  defaultDecimals(overrides?: CallOverrides): Promise<number>;
+
+  getCurrentDecimals(
+    _feedId: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<number>;
+
+  getCurrentDecimalsBulk(
+    _feedIds: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  getDecimals(
+    _feedId: PromiseOrValue<BytesLike>,
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<number>;
+
+  getDecimalsBulk(
+    _feedIds: PromiseOrValue<BytesLike>,
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  getScheduledDecimalsChanges(
+    _feedId: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<
+    [number[], BigNumber[], boolean[]] & {
+      _decimals: number[];
+      _validFromEpochId: BigNumber[];
+      _fixed: boolean[];
+    }
+  >;
+
+  callStatic: {
+    decimalsUpdateOffset(overrides?: CallOverrides): Promise<number>;
+
+    defaultDecimals(overrides?: CallOverrides): Promise<number>;
+
+    getCurrentDecimals(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<number>;
+
+    getCurrentDecimalsBulk(
+      _feedIds: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    getDecimals(
+      _feedId: PromiseOrValue<BytesLike>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<number>;
+
+    getDecimalsBulk(
+      _feedIds: PromiseOrValue<BytesLike>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    getScheduledDecimalsChanges(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<
+      [number[], BigNumber[], boolean[]] & {
+        _decimals: number[];
+        _validFromEpochId: BigNumber[];
+        _fixed: boolean[];
+      }
+    >;
+  };
+
+  filters: {
+    "DecimalsChanged(bytes21,int8,uint24)"(
+      feedId?: PromiseOrValue<BytesLike> | null,
+      decimals?: null,
+      rewardEpochId?: null
+    ): DecimalsChangedEventFilter;
+    DecimalsChanged(
+      feedId?: PromiseOrValue<BytesLike> | null,
+      decimals?: null,
+      rewardEpochId?: null
+    ): DecimalsChangedEventFilter;
+  };
+
+  estimateGas: {
+    decimalsUpdateOffset(overrides?: CallOverrides): Promise<BigNumber>;
+
+    defaultDecimals(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentDecimals(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getCurrentDecimalsBulk(
+      _feedIds: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getDecimals(
+      _feedId: PromiseOrValue<BytesLike>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getDecimalsBulk(
+      _feedIds: PromiseOrValue<BytesLike>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getScheduledDecimalsChanges(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    decimalsUpdateOffset(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    defaultDecimals(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getCurrentDecimals(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getCurrentDecimalsBulk(
+      _feedIds: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getDecimals(
+      _feedId: PromiseOrValue<BytesLike>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getDecimalsBulk(
+      _feedIds: PromiseOrValue<BytesLike>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getScheduledDecimalsChanges(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IFtsoFeedIdConverter.ts

@@ -0,0 +1,142 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export interface IFtsoFeedIdConverterInterface extends utils.Interface {
+  functions: {
+    "getFeedCategoryAndName(bytes21)": FunctionFragment;
+    "getFeedId(uint8,string)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic: "getFeedCategoryAndName" | "getFeedId"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "getFeedCategoryAndName",
+    values: [PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFeedId",
+    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "getFeedCategoryAndName",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getFeedId", data: BytesLike): Result;
+
+  events: {};
+}
+
+export interface IFtsoFeedIdConverter extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IFtsoFeedIdConverterInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    getFeedCategoryAndName(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[number, string] & { _category: number; _name: string }>;
+
+    getFeedId(
+      _category: PromiseOrValue<BigNumberish>,
+      _name: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[string]>;
+  };
+
+  getFeedCategoryAndName(
+    _feedId: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<[number, string] & { _category: number; _name: string }>;
+
+  getFeedId(
+    _category: PromiseOrValue<BigNumberish>,
+    _name: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  callStatic: {
+    getFeedCategoryAndName(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[number, string] & { _category: number; _name: string }>;
+
+    getFeedId(
+      _category: PromiseOrValue<BigNumberish>,
+      _name: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    getFeedCategoryAndName(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getFeedId(
+      _category: PromiseOrValue<BigNumberish>,
+      _name: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    getFeedCategoryAndName(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getFeedId(
+      _category: PromiseOrValue<BigNumberish>,
+      _name: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IFtsoFeedPublisher.ts

@@ -0,0 +1,284 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export declare namespace IFtsoFeedPublisher {
+  export type FeedStruct = {
+    votingRoundId: PromiseOrValue<BigNumberish>;
+    id: PromiseOrValue<BytesLike>;
+    value: PromiseOrValue<BigNumberish>;
+    turnoutBIPS: PromiseOrValue<BigNumberish>;
+    decimals: PromiseOrValue<BigNumberish>;
+  };
+
+  export type FeedStructOutput = [number, string, number, number, number] & {
+    votingRoundId: number;
+    id: string;
+    value: number;
+    turnoutBIPS: number;
+    decimals: number;
+  };
+
+  export type FeedWithProofStruct = {
+    merkleProof: PromiseOrValue<BytesLike>[];
+    body: IFtsoFeedPublisher.FeedStruct;
+  };
+
+  export type FeedWithProofStructOutput = [
+    string[],
+    IFtsoFeedPublisher.FeedStructOutput
+  ] & { merkleProof: string[]; body: IFtsoFeedPublisher.FeedStructOutput };
+}
+
+export interface IFtsoFeedPublisherInterface extends utils.Interface {
+  functions: {
+    "feedsHistorySize()": FunctionFragment;
+    "ftsoProtocolId()": FunctionFragment;
+    "getCurrentFeed(bytes21)": FunctionFragment;
+    "getFeed(bytes21,uint256)": FunctionFragment;
+    "publish((bytes32[],(uint32,bytes21,int32,uint16,int8))[])": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "feedsHistorySize"
+      | "ftsoProtocolId"
+      | "getCurrentFeed"
+      | "getFeed"
+      | "publish"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "feedsHistorySize",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "ftsoProtocolId",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentFeed",
+    values: [PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFeed",
+    values: [PromiseOrValue<BytesLike>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "publish",
+    values: [IFtsoFeedPublisher.FeedWithProofStruct[]]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "feedsHistorySize",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "ftsoProtocolId",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentFeed",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getFeed", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "publish", data: BytesLike): Result;
+
+  events: {
+    "FtsoFeedPublished(uint32,bytes21,int32,uint16,int8)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "FtsoFeedPublished"): EventFragment;
+}
+
+export interface FtsoFeedPublishedEventObject {
+  votingRoundId: number;
+  id: string;
+  value: number;
+  turnoutBIPS: number;
+  decimals: number;
+}
+export type FtsoFeedPublishedEvent = TypedEvent<
+  [number, string, number, number, number],
+  FtsoFeedPublishedEventObject
+>;
+
+export type FtsoFeedPublishedEventFilter =
+  TypedEventFilter<FtsoFeedPublishedEvent>;
+
+export interface IFtsoFeedPublisher extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IFtsoFeedPublisherInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    feedsHistorySize(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    ftsoProtocolId(overrides?: CallOverrides): Promise<[number]>;
+
+    getCurrentFeed(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[IFtsoFeedPublisher.FeedStructOutput]>;
+
+    getFeed(
+      _feedId: PromiseOrValue<BytesLike>,
+      _votingRoundId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[IFtsoFeedPublisher.FeedStructOutput]>;
+
+    publish(
+      _proofs: IFtsoFeedPublisher.FeedWithProofStruct[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  feedsHistorySize(overrides?: CallOverrides): Promise<BigNumber>;
+
+  ftsoProtocolId(overrides?: CallOverrides): Promise<number>;
+
+  getCurrentFeed(
+    _feedId: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<IFtsoFeedPublisher.FeedStructOutput>;
+
+  getFeed(
+    _feedId: PromiseOrValue<BytesLike>,
+    _votingRoundId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<IFtsoFeedPublisher.FeedStructOutput>;
+
+  publish(
+    _proofs: IFtsoFeedPublisher.FeedWithProofStruct[],
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    feedsHistorySize(overrides?: CallOverrides): Promise<BigNumber>;
+
+    ftsoProtocolId(overrides?: CallOverrides): Promise<number>;
+
+    getCurrentFeed(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<IFtsoFeedPublisher.FeedStructOutput>;
+
+    getFeed(
+      _feedId: PromiseOrValue<BytesLike>,
+      _votingRoundId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<IFtsoFeedPublisher.FeedStructOutput>;
+
+    publish(
+      _proofs: IFtsoFeedPublisher.FeedWithProofStruct[],
+      overrides?: CallOverrides
+    ): Promise<void>;
+  };
+
+  filters: {
+    "FtsoFeedPublished(uint32,bytes21,int32,uint16,int8)"(
+      votingRoundId?: PromiseOrValue<BigNumberish> | null,
+      id?: PromiseOrValue<BytesLike> | null,
+      value?: null,
+      turnoutBIPS?: null,
+      decimals?: null
+    ): FtsoFeedPublishedEventFilter;
+    FtsoFeedPublished(
+      votingRoundId?: PromiseOrValue<BigNumberish> | null,
+      id?: PromiseOrValue<BytesLike> | null,
+      value?: null,
+      turnoutBIPS?: null,
+      decimals?: null
+    ): FtsoFeedPublishedEventFilter;
+  };
+
+  estimateGas: {
+    feedsHistorySize(overrides?: CallOverrides): Promise<BigNumber>;
+
+    ftsoProtocolId(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentFeed(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getFeed(
+      _feedId: PromiseOrValue<BytesLike>,
+      _votingRoundId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    publish(
+      _proofs: IFtsoFeedPublisher.FeedWithProofStruct[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    feedsHistorySize(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    ftsoProtocolId(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getCurrentFeed(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getFeed(
+      _feedId: PromiseOrValue<BytesLike>,
+      _votingRoundId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    publish(
+      _proofs: IFtsoFeedPublisher.FeedWithProofStruct[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IFtsoInflationConfigurations.ts

@@ -0,0 +1,160 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export declare namespace IFtsoInflationConfigurations {
+  export type FtsoConfigurationStruct = {
+    feedIds: PromiseOrValue<BytesLike>;
+    inflationShare: PromiseOrValue<BigNumberish>;
+    minRewardedTurnoutBIPS: PromiseOrValue<BigNumberish>;
+    primaryBandRewardSharePPM: PromiseOrValue<BigNumberish>;
+    secondaryBandWidthPPMs: PromiseOrValue<BytesLike>;
+    mode: PromiseOrValue<BigNumberish>;
+  };
+
+  export type FtsoConfigurationStructOutput = [
+    string,
+    number,
+    number,
+    number,
+    string,
+    number
+  ] & {
+    feedIds: string;
+    inflationShare: number;
+    minRewardedTurnoutBIPS: number;
+    primaryBandRewardSharePPM: number;
+    secondaryBandWidthPPMs: string;
+    mode: number;
+  };
+}
+
+export interface IFtsoInflationConfigurationsInterface extends utils.Interface {
+  functions: {
+    "getFtsoConfiguration(uint256)": FunctionFragment;
+    "getFtsoConfigurations()": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic: "getFtsoConfiguration" | "getFtsoConfigurations"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "getFtsoConfiguration",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFtsoConfigurations",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "getFtsoConfiguration",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getFtsoConfigurations",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface IFtsoInflationConfigurations extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IFtsoInflationConfigurationsInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    getFtsoConfiguration(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[IFtsoInflationConfigurations.FtsoConfigurationStructOutput]>;
+
+    getFtsoConfigurations(
+      overrides?: CallOverrides
+    ): Promise<[IFtsoInflationConfigurations.FtsoConfigurationStructOutput[]]>;
+  };
+
+  getFtsoConfiguration(
+    _index: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<IFtsoInflationConfigurations.FtsoConfigurationStructOutput>;
+
+  getFtsoConfigurations(
+    overrides?: CallOverrides
+  ): Promise<IFtsoInflationConfigurations.FtsoConfigurationStructOutput[]>;
+
+  callStatic: {
+    getFtsoConfiguration(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<IFtsoInflationConfigurations.FtsoConfigurationStructOutput>;
+
+    getFtsoConfigurations(
+      overrides?: CallOverrides
+    ): Promise<IFtsoInflationConfigurations.FtsoConfigurationStructOutput[]>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    getFtsoConfiguration(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getFtsoConfigurations(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    getFtsoConfiguration(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getFtsoConfigurations(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IFtsoManager.ts

@@ -0,0 +1,612 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export interface IFtsoManagerInterface extends utils.Interface {
+  functions: {
+    "active()": FunctionFragment;
+    "getCurrentPriceEpochData()": FunctionFragment;
+    "getCurrentPriceEpochId()": FunctionFragment;
+    "getCurrentRewardEpoch()": FunctionFragment;
+    "getFallbackMode()": FunctionFragment;
+    "getFtsos()": FunctionFragment;
+    "getPriceEpochConfiguration()": FunctionFragment;
+    "getRewardEpochConfiguration()": FunctionFragment;
+    "getRewardEpochToExpireNext()": FunctionFragment;
+    "getRewardEpochVotePowerBlock(uint256)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "active"
+      | "getCurrentPriceEpochData"
+      | "getCurrentPriceEpochId"
+      | "getCurrentRewardEpoch"
+      | "getFallbackMode"
+      | "getFtsos"
+      | "getPriceEpochConfiguration"
+      | "getRewardEpochConfiguration"
+      | "getRewardEpochToExpireNext"
+      | "getRewardEpochVotePowerBlock"
+  ): FunctionFragment;
+
+  encodeFunctionData(functionFragment: "active", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentPriceEpochData",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentPriceEpochId",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentRewardEpoch",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFallbackMode",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "getFtsos", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "getPriceEpochConfiguration",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRewardEpochConfiguration",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRewardEpochToExpireNext",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRewardEpochVotePowerBlock",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "active", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentPriceEpochData",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentPriceEpochId",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentRewardEpoch",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getFallbackMode",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getFtsos", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getPriceEpochConfiguration",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRewardEpochConfiguration",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRewardEpochToExpireNext",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRewardEpochVotePowerBlock",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "AccruingUnearnedRewardsFailed(uint256)": EventFragment;
+    "DistributingRewardsFailed(address,uint256)": EventFragment;
+    "FallbackMode(bool)": EventFragment;
+    "FinalizingPriceEpochFailed(address,uint256,uint8)": EventFragment;
+    "FtsoAdded(address,bool)": EventFragment;
+    "FtsoFallbackMode(address,bool)": EventFragment;
+    "InitializingCurrentEpochStateForRevealFailed(address,uint256)": EventFragment;
+    "PriceEpochFinalized(address,uint256)": EventFragment;
+    "RewardEpochFinalized(uint256,uint256)": EventFragment;
+    "UseGoodRandomSet(bool,uint256)": EventFragment;
+  };
+
+  getEvent(
+    nameOrSignatureOrTopic: "AccruingUnearnedRewardsFailed"
+  ): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "DistributingRewardsFailed"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "FallbackMode"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "FinalizingPriceEpochFailed"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "FtsoAdded"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "FtsoFallbackMode"): EventFragment;
+  getEvent(
+    nameOrSignatureOrTopic: "InitializingCurrentEpochStateForRevealFailed"
+  ): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "PriceEpochFinalized"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "RewardEpochFinalized"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "UseGoodRandomSet"): EventFragment;
+}
+
+export interface AccruingUnearnedRewardsFailedEventObject {
+  epochId: BigNumber;
+}
+export type AccruingUnearnedRewardsFailedEvent = TypedEvent<
+  [BigNumber],
+  AccruingUnearnedRewardsFailedEventObject
+>;
+
+export type AccruingUnearnedRewardsFailedEventFilter =
+  TypedEventFilter<AccruingUnearnedRewardsFailedEvent>;
+
+export interface DistributingRewardsFailedEventObject {
+  ftso: string;
+  epochId: BigNumber;
+}
+export type DistributingRewardsFailedEvent = TypedEvent<
+  [string, BigNumber],
+  DistributingRewardsFailedEventObject
+>;
+
+export type DistributingRewardsFailedEventFilter =
+  TypedEventFilter<DistributingRewardsFailedEvent>;
+
+export interface FallbackModeEventObject {
+  fallbackMode: boolean;
+}
+export type FallbackModeEvent = TypedEvent<[boolean], FallbackModeEventObject>;
+
+export type FallbackModeEventFilter = TypedEventFilter<FallbackModeEvent>;
+
+export interface FinalizingPriceEpochFailedEventObject {
+  ftso: string;
+  epochId: BigNumber;
+  failingType: number;
+}
+export type FinalizingPriceEpochFailedEvent = TypedEvent<
+  [string, BigNumber, number],
+  FinalizingPriceEpochFailedEventObject
+>;
+
+export type FinalizingPriceEpochFailedEventFilter =
+  TypedEventFilter<FinalizingPriceEpochFailedEvent>;
+
+export interface FtsoAddedEventObject {
+  ftso: string;
+  add: boolean;
+}
+export type FtsoAddedEvent = TypedEvent<
+  [string, boolean],
+  FtsoAddedEventObject
+>;
+
+export type FtsoAddedEventFilter = TypedEventFilter<FtsoAddedEvent>;
+
+export interface FtsoFallbackModeEventObject {
+  ftso: string;
+  fallbackMode: boolean;
+}
+export type FtsoFallbackModeEvent = TypedEvent<
+  [string, boolean],
+  FtsoFallbackModeEventObject
+>;
+
+export type FtsoFallbackModeEventFilter =
+  TypedEventFilter<FtsoFallbackModeEvent>;
+
+export interface InitializingCurrentEpochStateForRevealFailedEventObject {
+  ftso: string;
+  epochId: BigNumber;
+}
+export type InitializingCurrentEpochStateForRevealFailedEvent = TypedEvent<
+  [string, BigNumber],
+  InitializingCurrentEpochStateForRevealFailedEventObject
+>;
+
+export type InitializingCurrentEpochStateForRevealFailedEventFilter =
+  TypedEventFilter<InitializingCurrentEpochStateForRevealFailedEvent>;
+
+export interface PriceEpochFinalizedEventObject {
+  chosenFtso: string;
+  rewardEpochId: BigNumber;
+}
+export type PriceEpochFinalizedEvent = TypedEvent<
+  [string, BigNumber],
+  PriceEpochFinalizedEventObject
+>;
+
+export type PriceEpochFinalizedEventFilter =
+  TypedEventFilter<PriceEpochFinalizedEvent>;
+
+export interface RewardEpochFinalizedEventObject {
+  votepowerBlock: BigNumber;
+  startBlock: BigNumber;
+}
+export type RewardEpochFinalizedEvent = TypedEvent<
+  [BigNumber, BigNumber],
+  RewardEpochFinalizedEventObject
+>;
+
+export type RewardEpochFinalizedEventFilter =
+  TypedEventFilter<RewardEpochFinalizedEvent>;
+
+export interface UseGoodRandomSetEventObject {
+  useGoodRandom: boolean;
+  maxWaitForGoodRandomSeconds: BigNumber;
+}
+export type UseGoodRandomSetEvent = TypedEvent<
+  [boolean, BigNumber],
+  UseGoodRandomSetEventObject
+>;
+
+export type UseGoodRandomSetEventFilter =
+  TypedEventFilter<UseGoodRandomSetEvent>;
+
+export interface IFtsoManager extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IFtsoManagerInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    active(overrides?: CallOverrides): Promise<[boolean]>;
+
+    getCurrentPriceEpochData(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+        _priceEpochId: BigNumber;
+        _priceEpochStartTimestamp: BigNumber;
+        _priceEpochEndTimestamp: BigNumber;
+        _priceEpochRevealEndTimestamp: BigNumber;
+        _currentTimestamp: BigNumber;
+      }
+    >;
+
+    getCurrentPriceEpochId(
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { _priceEpochId: BigNumber }>;
+
+    getCurrentRewardEpoch(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    getFallbackMode(
+      overrides?: CallOverrides
+    ): Promise<
+      [boolean, string[], boolean[]] & {
+        _fallbackMode: boolean;
+        _ftsos: string[];
+        _ftsoInFallbackMode: boolean[];
+      }
+    >;
+
+    getFtsos(
+      overrides?: CallOverrides
+    ): Promise<[string[]] & { _ftsos: string[] }>;
+
+    getPriceEpochConfiguration(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber] & {
+        _firstPriceEpochStartTs: BigNumber;
+        _priceEpochDurationSeconds: BigNumber;
+        _revealEpochDurationSeconds: BigNumber;
+      }
+    >;
+
+    getRewardEpochConfiguration(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & {
+        _firstRewardEpochStartTs: BigNumber;
+        _rewardEpochDurationSeconds: BigNumber;
+      }
+    >;
+
+    getRewardEpochToExpireNext(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    getRewardEpochVotePowerBlock(
+      _rewardEpoch: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+  };
+
+  active(overrides?: CallOverrides): Promise<boolean>;
+
+  getCurrentPriceEpochData(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+      _priceEpochId: BigNumber;
+      _priceEpochStartTimestamp: BigNumber;
+      _priceEpochEndTimestamp: BigNumber;
+      _priceEpochRevealEndTimestamp: BigNumber;
+      _currentTimestamp: BigNumber;
+    }
+  >;
+
+  getCurrentPriceEpochId(overrides?: CallOverrides): Promise<BigNumber>;
+
+  getCurrentRewardEpoch(overrides?: CallOverrides): Promise<BigNumber>;
+
+  getFallbackMode(
+    overrides?: CallOverrides
+  ): Promise<
+    [boolean, string[], boolean[]] & {
+      _fallbackMode: boolean;
+      _ftsos: string[];
+      _ftsoInFallbackMode: boolean[];
+    }
+  >;
+
+  getFtsos(overrides?: CallOverrides): Promise<string[]>;
+
+  getPriceEpochConfiguration(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, BigNumber] & {
+      _firstPriceEpochStartTs: BigNumber;
+      _priceEpochDurationSeconds: BigNumber;
+      _revealEpochDurationSeconds: BigNumber;
+    }
+  >;
+
+  getRewardEpochConfiguration(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber] & {
+      _firstRewardEpochStartTs: BigNumber;
+      _rewardEpochDurationSeconds: BigNumber;
+    }
+  >;
+
+  getRewardEpochToExpireNext(overrides?: CallOverrides): Promise<BigNumber>;
+
+  getRewardEpochVotePowerBlock(
+    _rewardEpoch: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  callStatic: {
+    active(overrides?: CallOverrides): Promise<boolean>;
+
+    getCurrentPriceEpochData(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+        _priceEpochId: BigNumber;
+        _priceEpochStartTimestamp: BigNumber;
+        _priceEpochEndTimestamp: BigNumber;
+        _priceEpochRevealEndTimestamp: BigNumber;
+        _currentTimestamp: BigNumber;
+      }
+    >;
+
+    getCurrentPriceEpochId(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentRewardEpoch(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getFallbackMode(
+      overrides?: CallOverrides
+    ): Promise<
+      [boolean, string[], boolean[]] & {
+        _fallbackMode: boolean;
+        _ftsos: string[];
+        _ftsoInFallbackMode: boolean[];
+      }
+    >;
+
+    getFtsos(overrides?: CallOverrides): Promise<string[]>;
+
+    getPriceEpochConfiguration(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber] & {
+        _firstPriceEpochStartTs: BigNumber;
+        _priceEpochDurationSeconds: BigNumber;
+        _revealEpochDurationSeconds: BigNumber;
+      }
+    >;
+
+    getRewardEpochConfiguration(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & {
+        _firstRewardEpochStartTs: BigNumber;
+        _rewardEpochDurationSeconds: BigNumber;
+      }
+    >;
+
+    getRewardEpochToExpireNext(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getRewardEpochVotePowerBlock(
+      _rewardEpoch: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  filters: {
+    "AccruingUnearnedRewardsFailed(uint256)"(
+      epochId?: null
+    ): AccruingUnearnedRewardsFailedEventFilter;
+    AccruingUnearnedRewardsFailed(
+      epochId?: null
+    ): AccruingUnearnedRewardsFailedEventFilter;
+
+    "DistributingRewardsFailed(address,uint256)"(
+      ftso?: null,
+      epochId?: null
+    ): DistributingRewardsFailedEventFilter;
+    DistributingRewardsFailed(
+      ftso?: null,
+      epochId?: null
+    ): DistributingRewardsFailedEventFilter;
+
+    "FallbackMode(bool)"(fallbackMode?: null): FallbackModeEventFilter;
+    FallbackMode(fallbackMode?: null): FallbackModeEventFilter;
+
+    "FinalizingPriceEpochFailed(address,uint256,uint8)"(
+      ftso?: null,
+      epochId?: null,
+      failingType?: null
+    ): FinalizingPriceEpochFailedEventFilter;
+    FinalizingPriceEpochFailed(
+      ftso?: null,
+      epochId?: null,
+      failingType?: null
+    ): FinalizingPriceEpochFailedEventFilter;
+
+    "FtsoAdded(address,bool)"(ftso?: null, add?: null): FtsoAddedEventFilter;
+    FtsoAdded(ftso?: null, add?: null): FtsoAddedEventFilter;
+
+    "FtsoFallbackMode(address,bool)"(
+      ftso?: null,
+      fallbackMode?: null
+    ): FtsoFallbackModeEventFilter;
+    FtsoFallbackMode(
+      ftso?: null,
+      fallbackMode?: null
+    ): FtsoFallbackModeEventFilter;
+
+    "InitializingCurrentEpochStateForRevealFailed(address,uint256)"(
+      ftso?: null,
+      epochId?: null
+    ): InitializingCurrentEpochStateForRevealFailedEventFilter;
+    InitializingCurrentEpochStateForRevealFailed(
+      ftso?: null,
+      epochId?: null
+    ): InitializingCurrentEpochStateForRevealFailedEventFilter;
+
+    "PriceEpochFinalized(address,uint256)"(
+      chosenFtso?: null,
+      rewardEpochId?: null
+    ): PriceEpochFinalizedEventFilter;
+    PriceEpochFinalized(
+      chosenFtso?: null,
+      rewardEpochId?: null
+    ): PriceEpochFinalizedEventFilter;
+
+    "RewardEpochFinalized(uint256,uint256)"(
+      votepowerBlock?: null,
+      startBlock?: null
+    ): RewardEpochFinalizedEventFilter;
+    RewardEpochFinalized(
+      votepowerBlock?: null,
+      startBlock?: null
+    ): RewardEpochFinalizedEventFilter;
+
+    "UseGoodRandomSet(bool,uint256)"(
+      useGoodRandom?: null,
+      maxWaitForGoodRandomSeconds?: null
+    ): UseGoodRandomSetEventFilter;
+    UseGoodRandomSet(
+      useGoodRandom?: null,
+      maxWaitForGoodRandomSeconds?: null
+    ): UseGoodRandomSetEventFilter;
+  };
+
+  estimateGas: {
+    active(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentPriceEpochData(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentPriceEpochId(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentRewardEpoch(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getFallbackMode(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getFtsos(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getPriceEpochConfiguration(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getRewardEpochConfiguration(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getRewardEpochToExpireNext(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getRewardEpochVotePowerBlock(
+      _rewardEpoch: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    active(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getCurrentPriceEpochData(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getCurrentPriceEpochId(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getCurrentRewardEpoch(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getFallbackMode(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getFtsos(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getPriceEpochConfiguration(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getRewardEpochConfiguration(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getRewardEpochToExpireNext(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getRewardEpochVotePowerBlock(
+      _rewardEpoch: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IFtsoRegistry.ts

@@ -0,0 +1,788 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export declare namespace IFtsoRegistry {
+  export type PriceInfoStruct = {
+    ftsoIndex: PromiseOrValue<BigNumberish>;
+    price: PromiseOrValue<BigNumberish>;
+    decimals: PromiseOrValue<BigNumberish>;
+    timestamp: PromiseOrValue<BigNumberish>;
+  };
+
+  export type PriceInfoStructOutput = [
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    BigNumber
+  ] & {
+    ftsoIndex: BigNumber;
+    price: BigNumber;
+    decimals: BigNumber;
+    timestamp: BigNumber;
+  };
+}
+
+export interface IFtsoRegistryInterface extends utils.Interface {
+  functions: {
+    "getAllCurrentPrices()": FunctionFragment;
+    "getCurrentPrice(string)": FunctionFragment;
+    "getCurrentPrice(uint256)": FunctionFragment;
+    "getCurrentPriceWithDecimals(uint256)": FunctionFragment;
+    "getCurrentPriceWithDecimals(string)": FunctionFragment;
+    "getCurrentPricesByIndices(uint256[])": FunctionFragment;
+    "getCurrentPricesBySymbols(string[])": FunctionFragment;
+    "getFtso(uint256)": FunctionFragment;
+    "getFtsoBySymbol(string)": FunctionFragment;
+    "getFtsoIndex(string)": FunctionFragment;
+    "getFtsoSymbol(uint256)": FunctionFragment;
+    "getFtsos(uint256[])": FunctionFragment;
+    "getSupportedFtsos()": FunctionFragment;
+    "getSupportedIndices()": FunctionFragment;
+    "getSupportedIndicesAndFtsos()": FunctionFragment;
+    "getSupportedIndicesAndSymbols()": FunctionFragment;
+    "getSupportedIndicesSymbolsAndFtsos()": FunctionFragment;
+    "getSupportedSymbols()": FunctionFragment;
+    "getSupportedSymbolsAndFtsos()": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "getAllCurrentPrices"
+      | "getCurrentPrice(string)"
+      | "getCurrentPrice(uint256)"
+      | "getCurrentPriceWithDecimals(uint256)"
+      | "getCurrentPriceWithDecimals(string)"
+      | "getCurrentPricesByIndices"
+      | "getCurrentPricesBySymbols"
+      | "getFtso"
+      | "getFtsoBySymbol"
+      | "getFtsoIndex"
+      | "getFtsoSymbol"
+      | "getFtsos"
+      | "getSupportedFtsos"
+      | "getSupportedIndices"
+      | "getSupportedIndicesAndFtsos"
+      | "getSupportedIndicesAndSymbols"
+      | "getSupportedIndicesSymbolsAndFtsos"
+      | "getSupportedSymbols"
+      | "getSupportedSymbolsAndFtsos"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "getAllCurrentPrices",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentPrice(string)",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentPrice(uint256)",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentPriceWithDecimals(uint256)",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentPriceWithDecimals(string)",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentPricesByIndices",
+    values: [PromiseOrValue<BigNumberish>[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentPricesBySymbols",
+    values: [PromiseOrValue<string>[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFtso",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFtsoBySymbol",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFtsoIndex",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFtsoSymbol",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFtsos",
+    values: [PromiseOrValue<BigNumberish>[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getSupportedFtsos",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getSupportedIndices",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getSupportedIndicesAndFtsos",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getSupportedIndicesAndSymbols",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getSupportedIndicesSymbolsAndFtsos",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getSupportedSymbols",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getSupportedSymbolsAndFtsos",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "getAllCurrentPrices",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentPrice(string)",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentPrice(uint256)",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentPriceWithDecimals(uint256)",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentPriceWithDecimals(string)",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentPricesByIndices",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentPricesBySymbols",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getFtso", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getFtsoBySymbol",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getFtsoIndex",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getFtsoSymbol",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getFtsos", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getSupportedFtsos",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getSupportedIndices",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getSupportedIndicesAndFtsos",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getSupportedIndicesAndSymbols",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getSupportedIndicesSymbolsAndFtsos",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getSupportedSymbols",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getSupportedSymbolsAndFtsos",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface IFtsoRegistry extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IFtsoRegistryInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    getAllCurrentPrices(
+      overrides?: CallOverrides
+    ): Promise<[IFtsoRegistry.PriceInfoStructOutput[]]>;
+
+    "getCurrentPrice(string)"(
+      _symbol: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { _price: BigNumber; _timestamp: BigNumber }
+    >;
+
+    "getCurrentPrice(uint256)"(
+      _ftsoIndex: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { _price: BigNumber; _timestamp: BigNumber }
+    >;
+
+    "getCurrentPriceWithDecimals(uint256)"(
+      _assetIndex: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber] & {
+        _price: BigNumber;
+        _timestamp: BigNumber;
+        _assetPriceUsdDecimals: BigNumber;
+      }
+    >;
+
+    "getCurrentPriceWithDecimals(string)"(
+      _symbol: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber] & {
+        _price: BigNumber;
+        _timestamp: BigNumber;
+        _assetPriceUsdDecimals: BigNumber;
+      }
+    >;
+
+    getCurrentPricesByIndices(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<[IFtsoRegistry.PriceInfoStructOutput[]]>;
+
+    getCurrentPricesBySymbols(
+      _symbols: PromiseOrValue<string>[],
+      overrides?: CallOverrides
+    ): Promise<[IFtsoRegistry.PriceInfoStructOutput[]]>;
+
+    getFtso(
+      _ftsoIndex: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[string] & { _activeFtsoAddress: string }>;
+
+    getFtsoBySymbol(
+      _symbol: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[string] & { _activeFtsoAddress: string }>;
+
+    getFtsoIndex(
+      _symbol: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { _assetIndex: BigNumber }>;
+
+    getFtsoSymbol(
+      _ftsoIndex: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[string] & { _symbol: string }>;
+
+    getFtsos(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<[string[]] & { _ftsos: string[] }>;
+
+    getSupportedFtsos(
+      overrides?: CallOverrides
+    ): Promise<[string[]] & { _ftsos: string[] }>;
+
+    getSupportedIndices(
+      overrides?: CallOverrides
+    ): Promise<[BigNumber[]] & { _supportedIndices: BigNumber[] }>;
+
+    getSupportedIndicesAndFtsos(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber[], string[]] & {
+        _supportedIndices: BigNumber[];
+        _ftsos: string[];
+      }
+    >;
+
+    getSupportedIndicesAndSymbols(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber[], string[]] & {
+        _supportedIndices: BigNumber[];
+        _supportedSymbols: string[];
+      }
+    >;
+
+    getSupportedIndicesSymbolsAndFtsos(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber[], string[], string[]] & {
+        _supportedIndices: BigNumber[];
+        _supportedSymbols: string[];
+        _ftsos: string[];
+      }
+    >;
+
+    getSupportedSymbols(
+      overrides?: CallOverrides
+    ): Promise<[string[]] & { _supportedSymbols: string[] }>;
+
+    getSupportedSymbolsAndFtsos(
+      overrides?: CallOverrides
+    ): Promise<
+      [string[], string[]] & { _supportedSymbols: string[]; _ftsos: string[] }
+    >;
+  };
+
+  getAllCurrentPrices(
+    overrides?: CallOverrides
+  ): Promise<IFtsoRegistry.PriceInfoStructOutput[]>;
+
+  "getCurrentPrice(string)"(
+    _symbol: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber] & { _price: BigNumber; _timestamp: BigNumber }
+  >;
+
+  "getCurrentPrice(uint256)"(
+    _ftsoIndex: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber] & { _price: BigNumber; _timestamp: BigNumber }
+  >;
+
+  "getCurrentPriceWithDecimals(uint256)"(
+    _assetIndex: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, BigNumber] & {
+      _price: BigNumber;
+      _timestamp: BigNumber;
+      _assetPriceUsdDecimals: BigNumber;
+    }
+  >;
+
+  "getCurrentPriceWithDecimals(string)"(
+    _symbol: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, BigNumber] & {
+      _price: BigNumber;
+      _timestamp: BigNumber;
+      _assetPriceUsdDecimals: BigNumber;
+    }
+  >;
+
+  getCurrentPricesByIndices(
+    _indices: PromiseOrValue<BigNumberish>[],
+    overrides?: CallOverrides
+  ): Promise<IFtsoRegistry.PriceInfoStructOutput[]>;
+
+  getCurrentPricesBySymbols(
+    _symbols: PromiseOrValue<string>[],
+    overrides?: CallOverrides
+  ): Promise<IFtsoRegistry.PriceInfoStructOutput[]>;
+
+  getFtso(
+    _ftsoIndex: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  getFtsoBySymbol(
+    _symbol: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  getFtsoIndex(
+    _symbol: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  getFtsoSymbol(
+    _ftsoIndex: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  getFtsos(
+    _indices: PromiseOrValue<BigNumberish>[],
+    overrides?: CallOverrides
+  ): Promise<string[]>;
+
+  getSupportedFtsos(overrides?: CallOverrides): Promise<string[]>;
+
+  getSupportedIndices(overrides?: CallOverrides): Promise<BigNumber[]>;
+
+  getSupportedIndicesAndFtsos(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber[], string[]] & {
+      _supportedIndices: BigNumber[];
+      _ftsos: string[];
+    }
+  >;
+
+  getSupportedIndicesAndSymbols(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber[], string[]] & {
+      _supportedIndices: BigNumber[];
+      _supportedSymbols: string[];
+    }
+  >;
+
+  getSupportedIndicesSymbolsAndFtsos(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber[], string[], string[]] & {
+      _supportedIndices: BigNumber[];
+      _supportedSymbols: string[];
+      _ftsos: string[];
+    }
+  >;
+
+  getSupportedSymbols(overrides?: CallOverrides): Promise<string[]>;
+
+  getSupportedSymbolsAndFtsos(
+    overrides?: CallOverrides
+  ): Promise<
+    [string[], string[]] & { _supportedSymbols: string[]; _ftsos: string[] }
+  >;
+
+  callStatic: {
+    getAllCurrentPrices(
+      overrides?: CallOverrides
+    ): Promise<IFtsoRegistry.PriceInfoStructOutput[]>;
+
+    "getCurrentPrice(string)"(
+      _symbol: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { _price: BigNumber; _timestamp: BigNumber }
+    >;
+
+    "getCurrentPrice(uint256)"(
+      _ftsoIndex: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { _price: BigNumber; _timestamp: BigNumber }
+    >;
+
+    "getCurrentPriceWithDecimals(uint256)"(
+      _assetIndex: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber] & {
+        _price: BigNumber;
+        _timestamp: BigNumber;
+        _assetPriceUsdDecimals: BigNumber;
+      }
+    >;
+
+    "getCurrentPriceWithDecimals(string)"(
+      _symbol: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber] & {
+        _price: BigNumber;
+        _timestamp: BigNumber;
+        _assetPriceUsdDecimals: BigNumber;
+      }
+    >;
+
+    getCurrentPricesByIndices(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<IFtsoRegistry.PriceInfoStructOutput[]>;
+
+    getCurrentPricesBySymbols(
+      _symbols: PromiseOrValue<string>[],
+      overrides?: CallOverrides
+    ): Promise<IFtsoRegistry.PriceInfoStructOutput[]>;
+
+    getFtso(
+      _ftsoIndex: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    getFtsoBySymbol(
+      _symbol: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    getFtsoIndex(
+      _symbol: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getFtsoSymbol(
+      _ftsoIndex: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    getFtsos(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<string[]>;
+
+    getSupportedFtsos(overrides?: CallOverrides): Promise<string[]>;
+
+    getSupportedIndices(overrides?: CallOverrides): Promise<BigNumber[]>;
+
+    getSupportedIndicesAndFtsos(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber[], string[]] & {
+        _supportedIndices: BigNumber[];
+        _ftsos: string[];
+      }
+    >;
+
+    getSupportedIndicesAndSymbols(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber[], string[]] & {
+        _supportedIndices: BigNumber[];
+        _supportedSymbols: string[];
+      }
+    >;
+
+    getSupportedIndicesSymbolsAndFtsos(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber[], string[], string[]] & {
+        _supportedIndices: BigNumber[];
+        _supportedSymbols: string[];
+        _ftsos: string[];
+      }
+    >;
+
+    getSupportedSymbols(overrides?: CallOverrides): Promise<string[]>;
+
+    getSupportedSymbolsAndFtsos(
+      overrides?: CallOverrides
+    ): Promise<
+      [string[], string[]] & { _supportedSymbols: string[]; _ftsos: string[] }
+    >;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    getAllCurrentPrices(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "getCurrentPrice(string)"(
+      _symbol: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    "getCurrentPrice(uint256)"(
+      _ftsoIndex: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    "getCurrentPriceWithDecimals(uint256)"(
+      _assetIndex: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    "getCurrentPriceWithDecimals(string)"(
+      _symbol: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getCurrentPricesByIndices(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getCurrentPricesBySymbols(
+      _symbols: PromiseOrValue<string>[],
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getFtso(
+      _ftsoIndex: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getFtsoBySymbol(
+      _symbol: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getFtsoIndex(
+      _symbol: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getFtsoSymbol(
+      _ftsoIndex: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getFtsos(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getSupportedFtsos(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getSupportedIndices(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getSupportedIndicesAndFtsos(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getSupportedIndicesAndSymbols(
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getSupportedIndicesSymbolsAndFtsos(
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getSupportedSymbols(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getSupportedSymbolsAndFtsos(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    getAllCurrentPrices(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    "getCurrentPrice(string)"(
+      _symbol: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    "getCurrentPrice(uint256)"(
+      _ftsoIndex: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    "getCurrentPriceWithDecimals(uint256)"(
+      _assetIndex: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    "getCurrentPriceWithDecimals(string)"(
+      _symbol: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getCurrentPricesByIndices(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getCurrentPricesBySymbols(
+      _symbols: PromiseOrValue<string>[],
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getFtso(
+      _ftsoIndex: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getFtsoBySymbol(
+      _symbol: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getFtsoIndex(
+      _symbol: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getFtsoSymbol(
+      _ftsoIndex: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getFtsos(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getSupportedFtsos(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getSupportedIndices(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getSupportedIndicesAndFtsos(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getSupportedIndicesAndSymbols(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getSupportedIndicesSymbolsAndFtsos(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getSupportedSymbols(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getSupportedSymbolsAndFtsos(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IFtsoRewardOffersManager.ts

@@ -0,0 +1,275 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  PayableOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export declare namespace IFtsoRewardOffersManager {
+  export type OfferStruct = {
+    amount: PromiseOrValue<BigNumberish>;
+    feedId: PromiseOrValue<BytesLike>;
+    minRewardedTurnoutBIPS: PromiseOrValue<BigNumberish>;
+    primaryBandRewardSharePPM: PromiseOrValue<BigNumberish>;
+    secondaryBandWidthPPM: PromiseOrValue<BigNumberish>;
+    claimBackAddress: PromiseOrValue<string>;
+  };
+
+  export type OfferStructOutput = [
+    BigNumber,
+    string,
+    number,
+    number,
+    number,
+    string
+  ] & {
+    amount: BigNumber;
+    feedId: string;
+    minRewardedTurnoutBIPS: number;
+    primaryBandRewardSharePPM: number;
+    secondaryBandWidthPPM: number;
+    claimBackAddress: string;
+  };
+}
+
+export interface IFtsoRewardOffersManagerInterface extends utils.Interface {
+  functions: {
+    "minimalRewardsOfferValueWei()": FunctionFragment;
+    "offerRewards(uint24,(uint120,bytes21,uint16,uint24,uint24,address)[])": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic: "minimalRewardsOfferValueWei" | "offerRewards"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "minimalRewardsOfferValueWei",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "offerRewards",
+    values: [
+      PromiseOrValue<BigNumberish>,
+      IFtsoRewardOffersManager.OfferStruct[]
+    ]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "minimalRewardsOfferValueWei",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "offerRewards",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "InflationRewardsOffered(uint24,bytes,bytes,uint256,uint16,uint24,bytes,uint16)": EventFragment;
+    "MinimalRewardsOfferValueSet(uint256)": EventFragment;
+    "RewardsOffered(uint24,bytes21,int8,uint256,uint16,uint24,uint24,address)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "InflationRewardsOffered"): EventFragment;
+  getEvent(
+    nameOrSignatureOrTopic: "MinimalRewardsOfferValueSet"
+  ): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "RewardsOffered"): EventFragment;
+}
+
+export interface InflationRewardsOfferedEventObject {
+  rewardEpochId: number;
+  feedIds: string;
+  decimals: string;
+  amount: BigNumber;
+  minRewardedTurnoutBIPS: number;
+  primaryBandRewardSharePPM: number;
+  secondaryBandWidthPPMs: string;
+  mode: number;
+}
+export type InflationRewardsOfferedEvent = TypedEvent<
+  [number, string, string, BigNumber, number, number, string, number],
+  InflationRewardsOfferedEventObject
+>;
+
+export type InflationRewardsOfferedEventFilter =
+  TypedEventFilter<InflationRewardsOfferedEvent>;
+
+export interface MinimalRewardsOfferValueSetEventObject {
+  valueWei: BigNumber;
+}
+export type MinimalRewardsOfferValueSetEvent = TypedEvent<
+  [BigNumber],
+  MinimalRewardsOfferValueSetEventObject
+>;
+
+export type MinimalRewardsOfferValueSetEventFilter =
+  TypedEventFilter<MinimalRewardsOfferValueSetEvent>;
+
+export interface RewardsOfferedEventObject {
+  rewardEpochId: number;
+  feedId: string;
+  decimals: number;
+  amount: BigNumber;
+  minRewardedTurnoutBIPS: number;
+  primaryBandRewardSharePPM: number;
+  secondaryBandWidthPPM: number;
+  claimBackAddress: string;
+}
+export type RewardsOfferedEvent = TypedEvent<
+  [number, string, number, BigNumber, number, number, number, string],
+  RewardsOfferedEventObject
+>;
+
+export type RewardsOfferedEventFilter = TypedEventFilter<RewardsOfferedEvent>;
+
+export interface IFtsoRewardOffersManager extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IFtsoRewardOffersManagerInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    minimalRewardsOfferValueWei(
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    offerRewards(
+      _nextRewardEpochId: PromiseOrValue<BigNumberish>,
+      _offers: IFtsoRewardOffersManager.OfferStruct[],
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  minimalRewardsOfferValueWei(overrides?: CallOverrides): Promise<BigNumber>;
+
+  offerRewards(
+    _nextRewardEpochId: PromiseOrValue<BigNumberish>,
+    _offers: IFtsoRewardOffersManager.OfferStruct[],
+    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    minimalRewardsOfferValueWei(overrides?: CallOverrides): Promise<BigNumber>;
+
+    offerRewards(
+      _nextRewardEpochId: PromiseOrValue<BigNumberish>,
+      _offers: IFtsoRewardOffersManager.OfferStruct[],
+      overrides?: CallOverrides
+    ): Promise<void>;
+  };
+
+  filters: {
+    "InflationRewardsOffered(uint24,bytes,bytes,uint256,uint16,uint24,bytes,uint16)"(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      feedIds?: null,
+      decimals?: null,
+      amount?: null,
+      minRewardedTurnoutBIPS?: null,
+      primaryBandRewardSharePPM?: null,
+      secondaryBandWidthPPMs?: null,
+      mode?: null
+    ): InflationRewardsOfferedEventFilter;
+    InflationRewardsOffered(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      feedIds?: null,
+      decimals?: null,
+      amount?: null,
+      minRewardedTurnoutBIPS?: null,
+      primaryBandRewardSharePPM?: null,
+      secondaryBandWidthPPMs?: null,
+      mode?: null
+    ): InflationRewardsOfferedEventFilter;
+
+    "MinimalRewardsOfferValueSet(uint256)"(
+      valueWei?: null
+    ): MinimalRewardsOfferValueSetEventFilter;
+    MinimalRewardsOfferValueSet(
+      valueWei?: null
+    ): MinimalRewardsOfferValueSetEventFilter;
+
+    "RewardsOffered(uint24,bytes21,int8,uint256,uint16,uint24,uint24,address)"(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      feedId?: null,
+      decimals?: null,
+      amount?: null,
+      minRewardedTurnoutBIPS?: null,
+      primaryBandRewardSharePPM?: null,
+      secondaryBandWidthPPM?: null,
+      claimBackAddress?: null
+    ): RewardsOfferedEventFilter;
+    RewardsOffered(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      feedId?: null,
+      decimals?: null,
+      amount?: null,
+      minRewardedTurnoutBIPS?: null,
+      primaryBandRewardSharePPM?: null,
+      secondaryBandWidthPPM?: null,
+      claimBackAddress?: null
+    ): RewardsOfferedEventFilter;
+  };
+
+  estimateGas: {
+    minimalRewardsOfferValueWei(overrides?: CallOverrides): Promise<BigNumber>;
+
+    offerRewards(
+      _nextRewardEpochId: PromiseOrValue<BigNumberish>,
+      _offers: IFtsoRewardOffersManager.OfferStruct[],
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    minimalRewardsOfferValueWei(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    offerRewards(
+      _nextRewardEpochId: PromiseOrValue<BigNumberish>,
+      _offers: IFtsoRewardOffersManager.OfferStruct[],
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IGenericRewardManager.ts

@@ -0,0 +1,472 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export interface IGenericRewardManagerInterface extends utils.Interface {
+  functions: {
+    "active()": FunctionFragment;
+    "allowedClaimRecipients(address)": FunctionFragment;
+    "claim(address,address,uint256,bool)": FunctionFragment;
+    "claimExecutors(address)": FunctionFragment;
+    "getStateOfRewards(address)": FunctionFragment;
+    "setAllowedClaimRecipients(address[])": FunctionFragment;
+    "setClaimExecutors(address[])": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "active"
+      | "allowedClaimRecipients"
+      | "claim"
+      | "claimExecutors"
+      | "getStateOfRewards"
+      | "setAllowedClaimRecipients"
+      | "setClaimExecutors"
+  ): FunctionFragment;
+
+  encodeFunctionData(functionFragment: "active", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "allowedClaimRecipients",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "claim",
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<boolean>
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "claimExecutors",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getStateOfRewards",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setAllowedClaimRecipients",
+    values: [PromiseOrValue<string>[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setClaimExecutors",
+    values: [PromiseOrValue<string>[]]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "active", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "allowedClaimRecipients",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "claim", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "claimExecutors",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getStateOfRewards",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "setAllowedClaimRecipients",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "setClaimExecutors",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "AllowedClaimRecipientsChanged(address,address[])": EventFragment;
+    "ClaimExecutorsChanged(address,address[])": EventFragment;
+    "RewardClaimed(address,address,uint256)": EventFragment;
+    "RewardManagerActivated(address)": EventFragment;
+    "RewardManagerDeactivated(address)": EventFragment;
+    "RewardsDistributed(address[],uint256[])": EventFragment;
+  };
+
+  getEvent(
+    nameOrSignatureOrTopic: "AllowedClaimRecipientsChanged"
+  ): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "ClaimExecutorsChanged"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "RewardClaimed"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "RewardManagerActivated"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "RewardManagerDeactivated"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "RewardsDistributed"): EventFragment;
+}
+
+export interface AllowedClaimRecipientsChangedEventObject {
+  rewardOwner: string;
+  recipients: string[];
+}
+export type AllowedClaimRecipientsChangedEvent = TypedEvent<
+  [string, string[]],
+  AllowedClaimRecipientsChangedEventObject
+>;
+
+export type AllowedClaimRecipientsChangedEventFilter =
+  TypedEventFilter<AllowedClaimRecipientsChangedEvent>;
+
+export interface ClaimExecutorsChangedEventObject {
+  rewardOwner: string;
+  executors: string[];
+}
+export type ClaimExecutorsChangedEvent = TypedEvent<
+  [string, string[]],
+  ClaimExecutorsChangedEventObject
+>;
+
+export type ClaimExecutorsChangedEventFilter =
+  TypedEventFilter<ClaimExecutorsChangedEvent>;
+
+export interface RewardClaimedEventObject {
+  beneficiary: string;
+  sentTo: string;
+  amount: BigNumber;
+}
+export type RewardClaimedEvent = TypedEvent<
+  [string, string, BigNumber],
+  RewardClaimedEventObject
+>;
+
+export type RewardClaimedEventFilter = TypedEventFilter<RewardClaimedEvent>;
+
+export interface RewardManagerActivatedEventObject {
+  rewardManager: string;
+}
+export type RewardManagerActivatedEvent = TypedEvent<
+  [string],
+  RewardManagerActivatedEventObject
+>;
+
+export type RewardManagerActivatedEventFilter =
+  TypedEventFilter<RewardManagerActivatedEvent>;
+
+export interface RewardManagerDeactivatedEventObject {
+  rewardManager: string;
+}
+export type RewardManagerDeactivatedEvent = TypedEvent<
+  [string],
+  RewardManagerDeactivatedEventObject
+>;
+
+export type RewardManagerDeactivatedEventFilter =
+  TypedEventFilter<RewardManagerDeactivatedEvent>;
+
+export interface RewardsDistributedEventObject {
+  addresses: string[];
+  rewards: BigNumber[];
+}
+export type RewardsDistributedEvent = TypedEvent<
+  [string[], BigNumber[]],
+  RewardsDistributedEventObject
+>;
+
+export type RewardsDistributedEventFilter =
+  TypedEventFilter<RewardsDistributedEvent>;
+
+export interface IGenericRewardManager extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IGenericRewardManagerInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    active(overrides?: CallOverrides): Promise<[boolean]>;
+
+    allowedClaimRecipients(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[string[]]>;
+
+    claim(
+      _rewardOwner: PromiseOrValue<string>,
+      _recipient: PromiseOrValue<string>,
+      _rewardAmount: PromiseOrValue<BigNumberish>,
+      _wrap: PromiseOrValue<boolean>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    claimExecutors(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[string[]]>;
+
+    getStateOfRewards(
+      _beneficiary: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & {
+        _totalReward: BigNumber;
+        _claimedReward: BigNumber;
+      }
+    >;
+
+    setAllowedClaimRecipients(
+      _recipients: PromiseOrValue<string>[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    setClaimExecutors(
+      _executors: PromiseOrValue<string>[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  active(overrides?: CallOverrides): Promise<boolean>;
+
+  allowedClaimRecipients(
+    _rewardOwner: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<string[]>;
+
+  claim(
+    _rewardOwner: PromiseOrValue<string>,
+    _recipient: PromiseOrValue<string>,
+    _rewardAmount: PromiseOrValue<BigNumberish>,
+    _wrap: PromiseOrValue<boolean>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  claimExecutors(
+    _rewardOwner: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<string[]>;
+
+  getStateOfRewards(
+    _beneficiary: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber] & {
+      _totalReward: BigNumber;
+      _claimedReward: BigNumber;
+    }
+  >;
+
+  setAllowedClaimRecipients(
+    _recipients: PromiseOrValue<string>[],
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  setClaimExecutors(
+    _executors: PromiseOrValue<string>[],
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    active(overrides?: CallOverrides): Promise<boolean>;
+
+    allowedClaimRecipients(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<string[]>;
+
+    claim(
+      _rewardOwner: PromiseOrValue<string>,
+      _recipient: PromiseOrValue<string>,
+      _rewardAmount: PromiseOrValue<BigNumberish>,
+      _wrap: PromiseOrValue<boolean>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    claimExecutors(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<string[]>;
+
+    getStateOfRewards(
+      _beneficiary: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & {
+        _totalReward: BigNumber;
+        _claimedReward: BigNumber;
+      }
+    >;
+
+    setAllowedClaimRecipients(
+      _recipients: PromiseOrValue<string>[],
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    setClaimExecutors(
+      _executors: PromiseOrValue<string>[],
+      overrides?: CallOverrides
+    ): Promise<void>;
+  };
+
+  filters: {
+    "AllowedClaimRecipientsChanged(address,address[])"(
+      rewardOwner?: null,
+      recipients?: null
+    ): AllowedClaimRecipientsChangedEventFilter;
+    AllowedClaimRecipientsChanged(
+      rewardOwner?: null,
+      recipients?: null
+    ): AllowedClaimRecipientsChangedEventFilter;
+
+    "ClaimExecutorsChanged(address,address[])"(
+      rewardOwner?: null,
+      executors?: null
+    ): ClaimExecutorsChangedEventFilter;
+    ClaimExecutorsChanged(
+      rewardOwner?: null,
+      executors?: null
+    ): ClaimExecutorsChangedEventFilter;
+
+    "RewardClaimed(address,address,uint256)"(
+      beneficiary?: PromiseOrValue<string> | null,
+      sentTo?: PromiseOrValue<string> | null,
+      amount?: null
+    ): RewardClaimedEventFilter;
+    RewardClaimed(
+      beneficiary?: PromiseOrValue<string> | null,
+      sentTo?: PromiseOrValue<string> | null,
+      amount?: null
+    ): RewardClaimedEventFilter;
+
+    "RewardManagerActivated(address)"(
+      rewardManager?: null
+    ): RewardManagerActivatedEventFilter;
+    RewardManagerActivated(
+      rewardManager?: null
+    ): RewardManagerActivatedEventFilter;
+
+    "RewardManagerDeactivated(address)"(
+      rewardManager?: null
+    ): RewardManagerDeactivatedEventFilter;
+    RewardManagerDeactivated(
+      rewardManager?: null
+    ): RewardManagerDeactivatedEventFilter;
+
+    "RewardsDistributed(address[],uint256[])"(
+      addresses?: null,
+      rewards?: null
+    ): RewardsDistributedEventFilter;
+    RewardsDistributed(
+      addresses?: null,
+      rewards?: null
+    ): RewardsDistributedEventFilter;
+  };
+
+  estimateGas: {
+    active(overrides?: CallOverrides): Promise<BigNumber>;
+
+    allowedClaimRecipients(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    claim(
+      _rewardOwner: PromiseOrValue<string>,
+      _recipient: PromiseOrValue<string>,
+      _rewardAmount: PromiseOrValue<BigNumberish>,
+      _wrap: PromiseOrValue<boolean>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    claimExecutors(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getStateOfRewards(
+      _beneficiary: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    setAllowedClaimRecipients(
+      _recipients: PromiseOrValue<string>[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    setClaimExecutors(
+      _executors: PromiseOrValue<string>[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    active(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    allowedClaimRecipients(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    claim(
+      _rewardOwner: PromiseOrValue<string>,
+      _recipient: PromiseOrValue<string>,
+      _rewardAmount: PromiseOrValue<BigNumberish>,
+      _wrap: PromiseOrValue<boolean>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    claimExecutors(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getStateOfRewards(
+      _beneficiary: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    setAllowedClaimRecipients(
+      _recipients: PromiseOrValue<string>[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    setClaimExecutors(
+      _executors: PromiseOrValue<string>[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IGovernanceSettings.ts

@@ -0,0 +1,165 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export interface IGovernanceSettingsInterface extends utils.Interface {
+  functions: {
+    "getExecutors()": FunctionFragment;
+    "getGovernanceAddress()": FunctionFragment;
+    "getTimelock()": FunctionFragment;
+    "isExecutor(address)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "getExecutors"
+      | "getGovernanceAddress"
+      | "getTimelock"
+      | "isExecutor"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "getExecutors",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getGovernanceAddress",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getTimelock",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isExecutor",
+    values: [PromiseOrValue<string>]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "getExecutors",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getGovernanceAddress",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getTimelock",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "isExecutor", data: BytesLike): Result;
+
+  events: {};
+}
+
+export interface IGovernanceSettings extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IGovernanceSettingsInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    getExecutors(overrides?: CallOverrides): Promise<[string[]]>;
+
+    getGovernanceAddress(overrides?: CallOverrides): Promise<[string]>;
+
+    getTimelock(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    isExecutor(
+      _address: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[boolean]>;
+  };
+
+  getExecutors(overrides?: CallOverrides): Promise<string[]>;
+
+  getGovernanceAddress(overrides?: CallOverrides): Promise<string>;
+
+  getTimelock(overrides?: CallOverrides): Promise<BigNumber>;
+
+  isExecutor(
+    _address: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<boolean>;
+
+  callStatic: {
+    getExecutors(overrides?: CallOverrides): Promise<string[]>;
+
+    getGovernanceAddress(overrides?: CallOverrides): Promise<string>;
+
+    getTimelock(overrides?: CallOverrides): Promise<BigNumber>;
+
+    isExecutor(
+      _address: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    getExecutors(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getGovernanceAddress(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getTimelock(overrides?: CallOverrides): Promise<BigNumber>;
+
+    isExecutor(
+      _address: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    getExecutors(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getGovernanceAddress(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getTimelock(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    isExecutor(
+      _address: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IGovernanceVotePower.ts

@@ -0,0 +1,278 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export interface IGovernanceVotePowerInterface extends utils.Interface {
+  functions: {
+    "delegate(address)": FunctionFragment;
+    "getDelegateOfAt(address,uint256)": FunctionFragment;
+    "getDelegateOfAtNow(address)": FunctionFragment;
+    "getVotes(address)": FunctionFragment;
+    "undelegate()": FunctionFragment;
+    "votePowerOfAt(address,uint256)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "delegate"
+      | "getDelegateOfAt"
+      | "getDelegateOfAtNow"
+      | "getVotes"
+      | "undelegate"
+      | "votePowerOfAt"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "delegate",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getDelegateOfAt",
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getDelegateOfAtNow",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getVotes",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "undelegate",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "votePowerOfAt",
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "delegate", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getDelegateOfAt",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getDelegateOfAtNow",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getVotes", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "undelegate", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "votePowerOfAt",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface IGovernanceVotePower extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IGovernanceVotePowerInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    delegate(
+      _to: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    getDelegateOfAt(
+      _who: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[string]>;
+
+    getDelegateOfAtNow(
+      _who: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[string]>;
+
+    getVotes(
+      _who: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    undelegate(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    votePowerOfAt(
+      _who: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+  };
+
+  delegate(
+    _to: PromiseOrValue<string>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  getDelegateOfAt(
+    _who: PromiseOrValue<string>,
+    _blockNumber: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  getDelegateOfAtNow(
+    _who: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  getVotes(
+    _who: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  undelegate(
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  votePowerOfAt(
+    _who: PromiseOrValue<string>,
+    _blockNumber: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  callStatic: {
+    delegate(
+      _to: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    getDelegateOfAt(
+      _who: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    getDelegateOfAtNow(
+      _who: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    getVotes(
+      _who: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    undelegate(overrides?: CallOverrides): Promise<void>;
+
+    votePowerOfAt(
+      _who: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    delegate(
+      _to: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    getDelegateOfAt(
+      _who: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getDelegateOfAtNow(
+      _who: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getVotes(
+      _who: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    undelegate(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    votePowerOfAt(
+      _who: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    delegate(
+      _to: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    getDelegateOfAt(
+      _who: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getDelegateOfAtNow(
+      _who: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getVotes(
+      _who: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    undelegate(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    votePowerOfAt(
+      _who: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IIncreaseManager.ts

@@ -0,0 +1,89 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "../../../common";
+
+export interface IIncreaseManagerInterface extends utils.Interface {
+  functions: {
+    "getIncentiveDuration()": FunctionFragment;
+  };
+
+  getFunction(nameOrSignatureOrTopic: "getIncentiveDuration"): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "getIncentiveDuration",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "getIncentiveDuration",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface IIncreaseManager extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IIncreaseManagerInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    getIncentiveDuration(overrides?: CallOverrides): Promise<[BigNumber]>;
+  };
+
+  getIncentiveDuration(overrides?: CallOverrides): Promise<BigNumber>;
+
+  callStatic: {
+    getIncentiveDuration(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    getIncentiveDuration(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    getIncentiveDuration(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IPChainStakeMirror.ts

@@ -0,0 +1,894 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export declare namespace IPChainStakeMirrorVerifier {
+  export type PChainStakeStruct = {
+    txId: PromiseOrValue<BytesLike>;
+    stakingType: PromiseOrValue<BigNumberish>;
+    inputAddress: PromiseOrValue<BytesLike>;
+    nodeId: PromiseOrValue<BytesLike>;
+    startTime: PromiseOrValue<BigNumberish>;
+    endTime: PromiseOrValue<BigNumberish>;
+    weight: PromiseOrValue<BigNumberish>;
+  };
+
+  export type PChainStakeStructOutput = [
+    string,
+    number,
+    string,
+    string,
+    BigNumber,
+    BigNumber,
+    BigNumber
+  ] & {
+    txId: string;
+    stakingType: number;
+    inputAddress: string;
+    nodeId: string;
+    startTime: BigNumber;
+    endTime: BigNumber;
+    weight: BigNumber;
+  };
+}
+
+export interface IPChainStakeMirrorInterface extends utils.Interface {
+  functions: {
+    "balanceOf(address)": FunctionFragment;
+    "balanceOfAt(address,uint256)": FunctionFragment;
+    "batchVotePowerOfAt(bytes20[],uint256)": FunctionFragment;
+    "isActiveStakeMirrored(bytes32,bytes20)": FunctionFragment;
+    "mirrorStake((bytes32,uint8,bytes20,bytes20,uint64,uint64,uint64),bytes32[])": FunctionFragment;
+    "stakesOf(address)": FunctionFragment;
+    "stakesOfAt(address,uint256)": FunctionFragment;
+    "totalSupply()": FunctionFragment;
+    "totalSupplyAt(uint256)": FunctionFragment;
+    "totalVotePower()": FunctionFragment;
+    "totalVotePowerAt(uint256)": FunctionFragment;
+    "totalVotePowerAtCached(uint256)": FunctionFragment;
+    "votePowerFromTo(address,bytes20)": FunctionFragment;
+    "votePowerFromToAt(address,bytes20,uint256)": FunctionFragment;
+    "votePowerOf(bytes20)": FunctionFragment;
+    "votePowerOfAt(bytes20,uint256)": FunctionFragment;
+    "votePowerOfAtCached(bytes20,uint256)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "balanceOf"
+      | "balanceOfAt"
+      | "batchVotePowerOfAt"
+      | "isActiveStakeMirrored"
+      | "mirrorStake"
+      | "stakesOf"
+      | "stakesOfAt"
+      | "totalSupply"
+      | "totalSupplyAt"
+      | "totalVotePower"
+      | "totalVotePowerAt"
+      | "totalVotePowerAtCached"
+      | "votePowerFromTo"
+      | "votePowerFromToAt"
+      | "votePowerOf"
+      | "votePowerOfAt"
+      | "votePowerOfAtCached"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "balanceOf",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "balanceOfAt",
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "batchVotePowerOfAt",
+    values: [PromiseOrValue<BytesLike>[], PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isActiveStakeMirrored",
+    values: [PromiseOrValue<BytesLike>, PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "mirrorStake",
+    values: [
+      IPChainStakeMirrorVerifier.PChainStakeStruct,
+      PromiseOrValue<BytesLike>[]
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "stakesOf",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "stakesOfAt",
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "totalSupply",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "totalSupplyAt",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "totalVotePower",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "totalVotePowerAt",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "totalVotePowerAtCached",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "votePowerFromTo",
+    values: [PromiseOrValue<string>, PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "votePowerFromToAt",
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<BytesLike>,
+      PromiseOrValue<BigNumberish>
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "votePowerOf",
+    values: [PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "votePowerOfAt",
+    values: [PromiseOrValue<BytesLike>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "votePowerOfAtCached",
+    values: [PromiseOrValue<BytesLike>, PromiseOrValue<BigNumberish>]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "balanceOfAt",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "batchVotePowerOfAt",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "isActiveStakeMirrored",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "mirrorStake",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "stakesOf", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "stakesOfAt", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "totalSupply",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "totalSupplyAt",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "totalVotePower",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "totalVotePowerAt",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "totalVotePowerAtCached",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "votePowerFromTo",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "votePowerFromToAt",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "votePowerOf",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "votePowerOfAt",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "votePowerOfAtCached",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "MaxUpdatesPerBlockSet(uint256)": EventFragment;
+    "StakeConfirmed(address,bytes20,bytes32,uint256,bytes32)": EventFragment;
+    "StakeEnded(address,bytes20,bytes32,uint256)": EventFragment;
+    "StakeRevoked(address,bytes20,bytes32,uint256)": EventFragment;
+    "VotePowerCacheCreated(bytes20,uint256)": EventFragment;
+    "VotePowerChanged(address,bytes20,uint256,uint256)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "MaxUpdatesPerBlockSet"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "StakeConfirmed"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "StakeEnded"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "StakeRevoked"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "VotePowerCacheCreated"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "VotePowerChanged"): EventFragment;
+}
+
+export interface MaxUpdatesPerBlockSetEventObject {
+  maxUpdatesPerBlock: BigNumber;
+}
+export type MaxUpdatesPerBlockSetEvent = TypedEvent<
+  [BigNumber],
+  MaxUpdatesPerBlockSetEventObject
+>;
+
+export type MaxUpdatesPerBlockSetEventFilter =
+  TypedEventFilter<MaxUpdatesPerBlockSetEvent>;
+
+export interface StakeConfirmedEventObject {
+  owner: string;
+  nodeId: string;
+  txHash: string;
+  amountWei: BigNumber;
+  pChainTxId: string;
+}
+export type StakeConfirmedEvent = TypedEvent<
+  [string, string, string, BigNumber, string],
+  StakeConfirmedEventObject
+>;
+
+export type StakeConfirmedEventFilter = TypedEventFilter<StakeConfirmedEvent>;
+
+export interface StakeEndedEventObject {
+  owner: string;
+  nodeId: string;
+  txHash: string;
+  amountWei: BigNumber;
+}
+export type StakeEndedEvent = TypedEvent<
+  [string, string, string, BigNumber],
+  StakeEndedEventObject
+>;
+
+export type StakeEndedEventFilter = TypedEventFilter<StakeEndedEvent>;
+
+export interface StakeRevokedEventObject {
+  owner: string;
+  nodeId: string;
+  txHash: string;
+  amountWei: BigNumber;
+}
+export type StakeRevokedEvent = TypedEvent<
+  [string, string, string, BigNumber],
+  StakeRevokedEventObject
+>;
+
+export type StakeRevokedEventFilter = TypedEventFilter<StakeRevokedEvent>;
+
+export interface VotePowerCacheCreatedEventObject {
+  nodeId: string;
+  blockNumber: BigNumber;
+}
+export type VotePowerCacheCreatedEvent = TypedEvent<
+  [string, BigNumber],
+  VotePowerCacheCreatedEventObject
+>;
+
+export type VotePowerCacheCreatedEventFilter =
+  TypedEventFilter<VotePowerCacheCreatedEvent>;
+
+export interface VotePowerChangedEventObject {
+  owner: string;
+  nodeId: string;
+  priorVotePower: BigNumber;
+  newVotePower: BigNumber;
+}
+export type VotePowerChangedEvent = TypedEvent<
+  [string, string, BigNumber, BigNumber],
+  VotePowerChangedEventObject
+>;
+
+export type VotePowerChangedEventFilter =
+  TypedEventFilter<VotePowerChangedEvent>;
+
+export interface IPChainStakeMirror extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IPChainStakeMirrorInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    balanceOf(
+      _owner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    balanceOfAt(
+      _owner: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    batchVotePowerOfAt(
+      _nodeIds: PromiseOrValue<BytesLike>[],
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber[]]>;
+
+    isActiveStakeMirrored(
+      _txId: PromiseOrValue<BytesLike>,
+      _inputAddress: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[boolean]>;
+
+    mirrorStake(
+      _stakeData: IPChainStakeMirrorVerifier.PChainStakeStruct,
+      _merkleProof: PromiseOrValue<BytesLike>[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    stakesOf(
+      _owner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<
+      [string[], BigNumber[]] & { _nodeIds: string[]; _amounts: BigNumber[] }
+    >;
+
+    stakesOfAt(
+      _owner: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [string[], BigNumber[]] & { _nodeIds: string[]; _amounts: BigNumber[] }
+    >;
+
+    totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    totalSupplyAt(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    totalVotePower(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    totalVotePowerAt(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    totalVotePowerAtCached(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    votePowerFromTo(
+      _owner: PromiseOrValue<string>,
+      _nodeId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    votePowerFromToAt(
+      _owner: PromiseOrValue<string>,
+      _nodeId: PromiseOrValue<BytesLike>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    votePowerOf(
+      _nodeId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    votePowerOfAt(
+      _nodeId: PromiseOrValue<BytesLike>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    votePowerOfAtCached(
+      _owner: PromiseOrValue<BytesLike>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  balanceOf(
+    _owner: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  balanceOfAt(
+    _owner: PromiseOrValue<string>,
+    _blockNumber: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  batchVotePowerOfAt(
+    _nodeIds: PromiseOrValue<BytesLike>[],
+    _blockNumber: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber[]>;
+
+  isActiveStakeMirrored(
+    _txId: PromiseOrValue<BytesLike>,
+    _inputAddress: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<boolean>;
+
+  mirrorStake(
+    _stakeData: IPChainStakeMirrorVerifier.PChainStakeStruct,
+    _merkleProof: PromiseOrValue<BytesLike>[],
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  stakesOf(
+    _owner: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<
+    [string[], BigNumber[]] & { _nodeIds: string[]; _amounts: BigNumber[] }
+  >;
+
+  stakesOfAt(
+    _owner: PromiseOrValue<string>,
+    _blockNumber: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<
+    [string[], BigNumber[]] & { _nodeIds: string[]; _amounts: BigNumber[] }
+  >;
+
+  totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
+
+  totalSupplyAt(
+    _blockNumber: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  totalVotePower(overrides?: CallOverrides): Promise<BigNumber>;
+
+  totalVotePowerAt(
+    _blockNumber: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  totalVotePowerAtCached(
+    _blockNumber: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  votePowerFromTo(
+    _owner: PromiseOrValue<string>,
+    _nodeId: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  votePowerFromToAt(
+    _owner: PromiseOrValue<string>,
+    _nodeId: PromiseOrValue<BytesLike>,
+    _blockNumber: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  votePowerOf(
+    _nodeId: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  votePowerOfAt(
+    _nodeId: PromiseOrValue<BytesLike>,
+    _blockNumber: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  votePowerOfAtCached(
+    _owner: PromiseOrValue<BytesLike>,
+    _blockNumber: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    balanceOf(
+      _owner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    balanceOfAt(
+      _owner: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    batchVotePowerOfAt(
+      _nodeIds: PromiseOrValue<BytesLike>[],
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber[]>;
+
+    isActiveStakeMirrored(
+      _txId: PromiseOrValue<BytesLike>,
+      _inputAddress: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    mirrorStake(
+      _stakeData: IPChainStakeMirrorVerifier.PChainStakeStruct,
+      _merkleProof: PromiseOrValue<BytesLike>[],
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    stakesOf(
+      _owner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<
+      [string[], BigNumber[]] & { _nodeIds: string[]; _amounts: BigNumber[] }
+    >;
+
+    stakesOfAt(
+      _owner: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [string[], BigNumber[]] & { _nodeIds: string[]; _amounts: BigNumber[] }
+    >;
+
+    totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
+
+    totalSupplyAt(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    totalVotePower(overrides?: CallOverrides): Promise<BigNumber>;
+
+    totalVotePowerAt(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    totalVotePowerAtCached(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    votePowerFromTo(
+      _owner: PromiseOrValue<string>,
+      _nodeId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    votePowerFromToAt(
+      _owner: PromiseOrValue<string>,
+      _nodeId: PromiseOrValue<BytesLike>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    votePowerOf(
+      _nodeId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    votePowerOfAt(
+      _nodeId: PromiseOrValue<BytesLike>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    votePowerOfAtCached(
+      _owner: PromiseOrValue<BytesLike>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  filters: {
+    "MaxUpdatesPerBlockSet(uint256)"(
+      maxUpdatesPerBlock?: null
+    ): MaxUpdatesPerBlockSetEventFilter;
+    MaxUpdatesPerBlockSet(
+      maxUpdatesPerBlock?: null
+    ): MaxUpdatesPerBlockSetEventFilter;
+
+    "StakeConfirmed(address,bytes20,bytes32,uint256,bytes32)"(
+      owner?: PromiseOrValue<string> | null,
+      nodeId?: PromiseOrValue<BytesLike> | null,
+      txHash?: PromiseOrValue<BytesLike> | null,
+      amountWei?: null,
+      pChainTxId?: null
+    ): StakeConfirmedEventFilter;
+    StakeConfirmed(
+      owner?: PromiseOrValue<string> | null,
+      nodeId?: PromiseOrValue<BytesLike> | null,
+      txHash?: PromiseOrValue<BytesLike> | null,
+      amountWei?: null,
+      pChainTxId?: null
+    ): StakeConfirmedEventFilter;
+
+    "StakeEnded(address,bytes20,bytes32,uint256)"(
+      owner?: PromiseOrValue<string> | null,
+      nodeId?: PromiseOrValue<BytesLike> | null,
+      txHash?: PromiseOrValue<BytesLike> | null,
+      amountWei?: null
+    ): StakeEndedEventFilter;
+    StakeEnded(
+      owner?: PromiseOrValue<string> | null,
+      nodeId?: PromiseOrValue<BytesLike> | null,
+      txHash?: PromiseOrValue<BytesLike> | null,
+      amountWei?: null
+    ): StakeEndedEventFilter;
+
+    "StakeRevoked(address,bytes20,bytes32,uint256)"(
+      owner?: PromiseOrValue<string> | null,
+      nodeId?: PromiseOrValue<BytesLike> | null,
+      txHash?: PromiseOrValue<BytesLike> | null,
+      amountWei?: null
+    ): StakeRevokedEventFilter;
+    StakeRevoked(
+      owner?: PromiseOrValue<string> | null,
+      nodeId?: PromiseOrValue<BytesLike> | null,
+      txHash?: PromiseOrValue<BytesLike> | null,
+      amountWei?: null
+    ): StakeRevokedEventFilter;
+
+    "VotePowerCacheCreated(bytes20,uint256)"(
+      nodeId?: null,
+      blockNumber?: null
+    ): VotePowerCacheCreatedEventFilter;
+    VotePowerCacheCreated(
+      nodeId?: null,
+      blockNumber?: null
+    ): VotePowerCacheCreatedEventFilter;
+
+    "VotePowerChanged(address,bytes20,uint256,uint256)"(
+      owner?: PromiseOrValue<string> | null,
+      nodeId?: PromiseOrValue<BytesLike> | null,
+      priorVotePower?: null,
+      newVotePower?: null
+    ): VotePowerChangedEventFilter;
+    VotePowerChanged(
+      owner?: PromiseOrValue<string> | null,
+      nodeId?: PromiseOrValue<BytesLike> | null,
+      priorVotePower?: null,
+      newVotePower?: null
+    ): VotePowerChangedEventFilter;
+  };
+
+  estimateGas: {
+    balanceOf(
+      _owner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    balanceOfAt(
+      _owner: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    batchVotePowerOfAt(
+      _nodeIds: PromiseOrValue<BytesLike>[],
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    isActiveStakeMirrored(
+      _txId: PromiseOrValue<BytesLike>,
+      _inputAddress: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    mirrorStake(
+      _stakeData: IPChainStakeMirrorVerifier.PChainStakeStruct,
+      _merkleProof: PromiseOrValue<BytesLike>[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    stakesOf(
+      _owner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    stakesOfAt(
+      _owner: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
+
+    totalSupplyAt(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    totalVotePower(overrides?: CallOverrides): Promise<BigNumber>;
+
+    totalVotePowerAt(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    totalVotePowerAtCached(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    votePowerFromTo(
+      _owner: PromiseOrValue<string>,
+      _nodeId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    votePowerFromToAt(
+      _owner: PromiseOrValue<string>,
+      _nodeId: PromiseOrValue<BytesLike>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    votePowerOf(
+      _nodeId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    votePowerOfAt(
+      _nodeId: PromiseOrValue<BytesLike>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    votePowerOfAtCached(
+      _owner: PromiseOrValue<BytesLike>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    balanceOf(
+      _owner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    balanceOfAt(
+      _owner: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    batchVotePowerOfAt(
+      _nodeIds: PromiseOrValue<BytesLike>[],
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    isActiveStakeMirrored(
+      _txId: PromiseOrValue<BytesLike>,
+      _inputAddress: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    mirrorStake(
+      _stakeData: IPChainStakeMirrorVerifier.PChainStakeStruct,
+      _merkleProof: PromiseOrValue<BytesLike>[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    stakesOf(
+      _owner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    stakesOfAt(
+      _owner: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    totalSupply(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    totalSupplyAt(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    totalVotePower(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    totalVotePowerAt(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    totalVotePowerAtCached(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    votePowerFromTo(
+      _owner: PromiseOrValue<string>,
+      _nodeId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    votePowerFromToAt(
+      _owner: PromiseOrValue<string>,
+      _nodeId: PromiseOrValue<BytesLike>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    votePowerOf(
+      _nodeId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    votePowerOfAt(
+      _nodeId: PromiseOrValue<BytesLike>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    votePowerOfAtCached(
+      _owner: PromiseOrValue<BytesLike>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IPChainStakeMirrorMultiSigVoting.ts

@@ -0,0 +1,553 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export declare namespace IPChainStakeMirrorMultiSigVoting {
+  export type PChainVotesStruct = {
+    merkleRoot: PromiseOrValue<BytesLike>;
+    votes: PromiseOrValue<string>[];
+  };
+
+  export type PChainVotesStructOutput = [string, string[]] & {
+    merkleRoot: string;
+    votes: string[];
+  };
+}
+
+export interface IPChainStakeMirrorMultiSigVotingInterface
+  extends utils.Interface {
+  functions: {
+    "getCurrentEpochId()": FunctionFragment;
+    "getEpochConfiguration()": FunctionFragment;
+    "getEpochId(uint256)": FunctionFragment;
+    "getMerkleRoot(uint256)": FunctionFragment;
+    "getVoters()": FunctionFragment;
+    "getVotes(uint256)": FunctionFragment;
+    "getVotingThreshold()": FunctionFragment;
+    "shouldVote(uint256,address)": FunctionFragment;
+    "submitValidatorUptimeVote(uint256,bytes20[])": FunctionFragment;
+    "submitVote(uint256,bytes32)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "getCurrentEpochId"
+      | "getEpochConfiguration"
+      | "getEpochId"
+      | "getMerkleRoot"
+      | "getVoters"
+      | "getVotes"
+      | "getVotingThreshold"
+      | "shouldVote"
+      | "submitValidatorUptimeVote"
+      | "submitVote"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "getCurrentEpochId",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getEpochConfiguration",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getEpochId",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getMerkleRoot",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(functionFragment: "getVoters", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "getVotes",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getVotingThreshold",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "shouldVote",
+    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "submitValidatorUptimeVote",
+    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BytesLike>[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "submitVote",
+    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BytesLike>]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "getCurrentEpochId",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getEpochConfiguration",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getEpochId", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getMerkleRoot",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getVoters", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "getVotes", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getVotingThreshold",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "shouldVote", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "submitValidatorUptimeVote",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "submitVote", data: BytesLike): Result;
+
+  events: {
+    "PChainStakeMirrorValidatorUptimeVoteSubmitted(uint256,uint256,address,bytes20[])": EventFragment;
+    "PChainStakeMirrorVoteSubmitted(uint256,address,bytes32)": EventFragment;
+    "PChainStakeMirrorVotersSet(address[])": EventFragment;
+    "PChainStakeMirrorVotingFinalized(uint256,bytes32)": EventFragment;
+    "PChainStakeMirrorVotingReset(uint256)": EventFragment;
+    "PChainStakeMirrorVotingThresholdSet(uint256)": EventFragment;
+  };
+
+  getEvent(
+    nameOrSignatureOrTopic: "PChainStakeMirrorValidatorUptimeVoteSubmitted"
+  ): EventFragment;
+  getEvent(
+    nameOrSignatureOrTopic: "PChainStakeMirrorVoteSubmitted"
+  ): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "PChainStakeMirrorVotersSet"): EventFragment;
+  getEvent(
+    nameOrSignatureOrTopic: "PChainStakeMirrorVotingFinalized"
+  ): EventFragment;
+  getEvent(
+    nameOrSignatureOrTopic: "PChainStakeMirrorVotingReset"
+  ): EventFragment;
+  getEvent(
+    nameOrSignatureOrTopic: "PChainStakeMirrorVotingThresholdSet"
+  ): EventFragment;
+}
+
+export interface PChainStakeMirrorValidatorUptimeVoteSubmittedEventObject {
+  rewardEpochId: BigNumber;
+  timestamp: BigNumber;
+  voter: string;
+  nodeIds: string[];
+}
+export type PChainStakeMirrorValidatorUptimeVoteSubmittedEvent = TypedEvent<
+  [BigNumber, BigNumber, string, string[]],
+  PChainStakeMirrorValidatorUptimeVoteSubmittedEventObject
+>;
+
+export type PChainStakeMirrorValidatorUptimeVoteSubmittedEventFilter =
+  TypedEventFilter<PChainStakeMirrorValidatorUptimeVoteSubmittedEvent>;
+
+export interface PChainStakeMirrorVoteSubmittedEventObject {
+  epochId: BigNumber;
+  voter: string;
+  merkleRoot: string;
+}
+export type PChainStakeMirrorVoteSubmittedEvent = TypedEvent<
+  [BigNumber, string, string],
+  PChainStakeMirrorVoteSubmittedEventObject
+>;
+
+export type PChainStakeMirrorVoteSubmittedEventFilter =
+  TypedEventFilter<PChainStakeMirrorVoteSubmittedEvent>;
+
+export interface PChainStakeMirrorVotersSetEventObject {
+  voters: string[];
+}
+export type PChainStakeMirrorVotersSetEvent = TypedEvent<
+  [string[]],
+  PChainStakeMirrorVotersSetEventObject
+>;
+
+export type PChainStakeMirrorVotersSetEventFilter =
+  TypedEventFilter<PChainStakeMirrorVotersSetEvent>;
+
+export interface PChainStakeMirrorVotingFinalizedEventObject {
+  epochId: BigNumber;
+  merkleRoot: string;
+}
+export type PChainStakeMirrorVotingFinalizedEvent = TypedEvent<
+  [BigNumber, string],
+  PChainStakeMirrorVotingFinalizedEventObject
+>;
+
+export type PChainStakeMirrorVotingFinalizedEventFilter =
+  TypedEventFilter<PChainStakeMirrorVotingFinalizedEvent>;
+
+export interface PChainStakeMirrorVotingResetEventObject {
+  epochId: BigNumber;
+}
+export type PChainStakeMirrorVotingResetEvent = TypedEvent<
+  [BigNumber],
+  PChainStakeMirrorVotingResetEventObject
+>;
+
+export type PChainStakeMirrorVotingResetEventFilter =
+  TypedEventFilter<PChainStakeMirrorVotingResetEvent>;
+
+export interface PChainStakeMirrorVotingThresholdSetEventObject {
+  votingThreshold: BigNumber;
+}
+export type PChainStakeMirrorVotingThresholdSetEvent = TypedEvent<
+  [BigNumber],
+  PChainStakeMirrorVotingThresholdSetEventObject
+>;
+
+export type PChainStakeMirrorVotingThresholdSetEventFilter =
+  TypedEventFilter<PChainStakeMirrorVotingThresholdSetEvent>;
+
+export interface IPChainStakeMirrorMultiSigVoting extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IPChainStakeMirrorMultiSigVotingInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    getCurrentEpochId(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    getEpochConfiguration(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & {
+        _firstEpochStartTs: BigNumber;
+        _epochDurationSeconds: BigNumber;
+      }
+    >;
+
+    getEpochId(
+      _timestamp: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    getMerkleRoot(
+      _epochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[string]>;
+
+    getVoters(overrides?: CallOverrides): Promise<[string[]]>;
+
+    getVotes(
+      _epochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[IPChainStakeMirrorMultiSigVoting.PChainVotesStructOutput[]]>;
+
+    getVotingThreshold(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    shouldVote(
+      _epochId: PromiseOrValue<BigNumberish>,
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[boolean]>;
+
+    submitValidatorUptimeVote(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _nodeIds: PromiseOrValue<BytesLike>[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    submitVote(
+      _epochId: PromiseOrValue<BigNumberish>,
+      _merkleRoot: PromiseOrValue<BytesLike>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  getCurrentEpochId(overrides?: CallOverrides): Promise<BigNumber>;
+
+  getEpochConfiguration(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber] & {
+      _firstEpochStartTs: BigNumber;
+      _epochDurationSeconds: BigNumber;
+    }
+  >;
+
+  getEpochId(
+    _timestamp: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  getMerkleRoot(
+    _epochId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  getVoters(overrides?: CallOverrides): Promise<string[]>;
+
+  getVotes(
+    _epochId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<IPChainStakeMirrorMultiSigVoting.PChainVotesStructOutput[]>;
+
+  getVotingThreshold(overrides?: CallOverrides): Promise<BigNumber>;
+
+  shouldVote(
+    _epochId: PromiseOrValue<BigNumberish>,
+    _voter: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<boolean>;
+
+  submitValidatorUptimeVote(
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    _nodeIds: PromiseOrValue<BytesLike>[],
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  submitVote(
+    _epochId: PromiseOrValue<BigNumberish>,
+    _merkleRoot: PromiseOrValue<BytesLike>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    getCurrentEpochId(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getEpochConfiguration(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & {
+        _firstEpochStartTs: BigNumber;
+        _epochDurationSeconds: BigNumber;
+      }
+    >;
+
+    getEpochId(
+      _timestamp: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getMerkleRoot(
+      _epochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    getVoters(overrides?: CallOverrides): Promise<string[]>;
+
+    getVotes(
+      _epochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<IPChainStakeMirrorMultiSigVoting.PChainVotesStructOutput[]>;
+
+    getVotingThreshold(overrides?: CallOverrides): Promise<BigNumber>;
+
+    shouldVote(
+      _epochId: PromiseOrValue<BigNumberish>,
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    submitValidatorUptimeVote(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _nodeIds: PromiseOrValue<BytesLike>[],
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    submitVote(
+      _epochId: PromiseOrValue<BigNumberish>,
+      _merkleRoot: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+  };
+
+  filters: {
+    "PChainStakeMirrorValidatorUptimeVoteSubmitted(uint256,uint256,address,bytes20[])"(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      timestamp?: PromiseOrValue<BigNumberish> | null,
+      voter?: null,
+      nodeIds?: null
+    ): PChainStakeMirrorValidatorUptimeVoteSubmittedEventFilter;
+    PChainStakeMirrorValidatorUptimeVoteSubmitted(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      timestamp?: PromiseOrValue<BigNumberish> | null,
+      voter?: null,
+      nodeIds?: null
+    ): PChainStakeMirrorValidatorUptimeVoteSubmittedEventFilter;
+
+    "PChainStakeMirrorVoteSubmitted(uint256,address,bytes32)"(
+      epochId?: null,
+      voter?: null,
+      merkleRoot?: null
+    ): PChainStakeMirrorVoteSubmittedEventFilter;
+    PChainStakeMirrorVoteSubmitted(
+      epochId?: null,
+      voter?: null,
+      merkleRoot?: null
+    ): PChainStakeMirrorVoteSubmittedEventFilter;
+
+    "PChainStakeMirrorVotersSet(address[])"(
+      voters?: null
+    ): PChainStakeMirrorVotersSetEventFilter;
+    PChainStakeMirrorVotersSet(
+      voters?: null
+    ): PChainStakeMirrorVotersSetEventFilter;
+
+    "PChainStakeMirrorVotingFinalized(uint256,bytes32)"(
+      epochId?: PromiseOrValue<BigNumberish> | null,
+      merkleRoot?: null
+    ): PChainStakeMirrorVotingFinalizedEventFilter;
+    PChainStakeMirrorVotingFinalized(
+      epochId?: PromiseOrValue<BigNumberish> | null,
+      merkleRoot?: null
+    ): PChainStakeMirrorVotingFinalizedEventFilter;
+
+    "PChainStakeMirrorVotingReset(uint256)"(
+      epochId?: null
+    ): PChainStakeMirrorVotingResetEventFilter;
+    PChainStakeMirrorVotingReset(
+      epochId?: null
+    ): PChainStakeMirrorVotingResetEventFilter;
+
+    "PChainStakeMirrorVotingThresholdSet(uint256)"(
+      votingThreshold?: null
+    ): PChainStakeMirrorVotingThresholdSetEventFilter;
+    PChainStakeMirrorVotingThresholdSet(
+      votingThreshold?: null
+    ): PChainStakeMirrorVotingThresholdSetEventFilter;
+  };
+
+  estimateGas: {
+    getCurrentEpochId(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getEpochConfiguration(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getEpochId(
+      _timestamp: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getMerkleRoot(
+      _epochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getVoters(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getVotes(
+      _epochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getVotingThreshold(overrides?: CallOverrides): Promise<BigNumber>;
+
+    shouldVote(
+      _epochId: PromiseOrValue<BigNumberish>,
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    submitValidatorUptimeVote(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _nodeIds: PromiseOrValue<BytesLike>[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    submitVote(
+      _epochId: PromiseOrValue<BigNumberish>,
+      _merkleRoot: PromiseOrValue<BytesLike>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    getCurrentEpochId(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getEpochConfiguration(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getEpochId(
+      _timestamp: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getMerkleRoot(
+      _epochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getVoters(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getVotes(
+      _epochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getVotingThreshold(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    shouldVote(
+      _epochId: PromiseOrValue<BigNumberish>,
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    submitValidatorUptimeVote(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _nodeIds: PromiseOrValue<BytesLike>[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    submitVote(
+      _epochId: PromiseOrValue<BigNumberish>,
+      _merkleRoot: PromiseOrValue<BytesLike>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IPChainVotePower.ts

@@ -0,0 +1,547 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export interface IPChainVotePowerInterface extends utils.Interface {
+  functions: {
+    "batchVotePowerOfAt(bytes20[],uint256)": FunctionFragment;
+    "stakesOf(address)": FunctionFragment;
+    "stakesOfAt(address,uint256)": FunctionFragment;
+    "totalVotePower()": FunctionFragment;
+    "totalVotePowerAt(uint256)": FunctionFragment;
+    "totalVotePowerAtCached(uint256)": FunctionFragment;
+    "votePowerFromTo(address,bytes20)": FunctionFragment;
+    "votePowerFromToAt(address,bytes20,uint256)": FunctionFragment;
+    "votePowerOf(bytes20)": FunctionFragment;
+    "votePowerOfAt(bytes20,uint256)": FunctionFragment;
+    "votePowerOfAtCached(bytes20,uint256)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "batchVotePowerOfAt"
+      | "stakesOf"
+      | "stakesOfAt"
+      | "totalVotePower"
+      | "totalVotePowerAt"
+      | "totalVotePowerAtCached"
+      | "votePowerFromTo"
+      | "votePowerFromToAt"
+      | "votePowerOf"
+      | "votePowerOfAt"
+      | "votePowerOfAtCached"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "batchVotePowerOfAt",
+    values: [PromiseOrValue<BytesLike>[], PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "stakesOf",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "stakesOfAt",
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "totalVotePower",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "totalVotePowerAt",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "totalVotePowerAtCached",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "votePowerFromTo",
+    values: [PromiseOrValue<string>, PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "votePowerFromToAt",
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<BytesLike>,
+      PromiseOrValue<BigNumberish>
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "votePowerOf",
+    values: [PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "votePowerOfAt",
+    values: [PromiseOrValue<BytesLike>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "votePowerOfAtCached",
+    values: [PromiseOrValue<BytesLike>, PromiseOrValue<BigNumberish>]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "batchVotePowerOfAt",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "stakesOf", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "stakesOfAt", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "totalVotePower",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "totalVotePowerAt",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "totalVotePowerAtCached",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "votePowerFromTo",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "votePowerFromToAt",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "votePowerOf",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "votePowerOfAt",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "votePowerOfAtCached",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "VotePowerCacheCreated(bytes20,uint256)": EventFragment;
+    "VotePowerChanged(address,bytes20,uint256,uint256)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "VotePowerCacheCreated"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "VotePowerChanged"): EventFragment;
+}
+
+export interface VotePowerCacheCreatedEventObject {
+  nodeId: string;
+  blockNumber: BigNumber;
+}
+export type VotePowerCacheCreatedEvent = TypedEvent<
+  [string, BigNumber],
+  VotePowerCacheCreatedEventObject
+>;
+
+export type VotePowerCacheCreatedEventFilter =
+  TypedEventFilter<VotePowerCacheCreatedEvent>;
+
+export interface VotePowerChangedEventObject {
+  owner: string;
+  nodeId: string;
+  priorVotePower: BigNumber;
+  newVotePower: BigNumber;
+}
+export type VotePowerChangedEvent = TypedEvent<
+  [string, string, BigNumber, BigNumber],
+  VotePowerChangedEventObject
+>;
+
+export type VotePowerChangedEventFilter =
+  TypedEventFilter<VotePowerChangedEvent>;
+
+export interface IPChainVotePower extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IPChainVotePowerInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    batchVotePowerOfAt(
+      _nodeIds: PromiseOrValue<BytesLike>[],
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber[]]>;
+
+    stakesOf(
+      _owner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<
+      [string[], BigNumber[]] & { _nodeIds: string[]; _amounts: BigNumber[] }
+    >;
+
+    stakesOfAt(
+      _owner: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [string[], BigNumber[]] & { _nodeIds: string[]; _amounts: BigNumber[] }
+    >;
+
+    totalVotePower(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    totalVotePowerAt(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    totalVotePowerAtCached(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    votePowerFromTo(
+      _owner: PromiseOrValue<string>,
+      _nodeId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    votePowerFromToAt(
+      _owner: PromiseOrValue<string>,
+      _nodeId: PromiseOrValue<BytesLike>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    votePowerOf(
+      _nodeId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    votePowerOfAt(
+      _nodeId: PromiseOrValue<BytesLike>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    votePowerOfAtCached(
+      _owner: PromiseOrValue<BytesLike>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  batchVotePowerOfAt(
+    _nodeIds: PromiseOrValue<BytesLike>[],
+    _blockNumber: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber[]>;
+
+  stakesOf(
+    _owner: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<
+    [string[], BigNumber[]] & { _nodeIds: string[]; _amounts: BigNumber[] }
+  >;
+
+  stakesOfAt(
+    _owner: PromiseOrValue<string>,
+    _blockNumber: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<
+    [string[], BigNumber[]] & { _nodeIds: string[]; _amounts: BigNumber[] }
+  >;
+
+  totalVotePower(overrides?: CallOverrides): Promise<BigNumber>;
+
+  totalVotePowerAt(
+    _blockNumber: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  totalVotePowerAtCached(
+    _blockNumber: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  votePowerFromTo(
+    _owner: PromiseOrValue<string>,
+    _nodeId: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  votePowerFromToAt(
+    _owner: PromiseOrValue<string>,
+    _nodeId: PromiseOrValue<BytesLike>,
+    _blockNumber: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  votePowerOf(
+    _nodeId: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  votePowerOfAt(
+    _nodeId: PromiseOrValue<BytesLike>,
+    _blockNumber: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  votePowerOfAtCached(
+    _owner: PromiseOrValue<BytesLike>,
+    _blockNumber: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    batchVotePowerOfAt(
+      _nodeIds: PromiseOrValue<BytesLike>[],
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber[]>;
+
+    stakesOf(
+      _owner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<
+      [string[], BigNumber[]] & { _nodeIds: string[]; _amounts: BigNumber[] }
+    >;
+
+    stakesOfAt(
+      _owner: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [string[], BigNumber[]] & { _nodeIds: string[]; _amounts: BigNumber[] }
+    >;
+
+    totalVotePower(overrides?: CallOverrides): Promise<BigNumber>;
+
+    totalVotePowerAt(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    totalVotePowerAtCached(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    votePowerFromTo(
+      _owner: PromiseOrValue<string>,
+      _nodeId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    votePowerFromToAt(
+      _owner: PromiseOrValue<string>,
+      _nodeId: PromiseOrValue<BytesLike>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    votePowerOf(
+      _nodeId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    votePowerOfAt(
+      _nodeId: PromiseOrValue<BytesLike>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    votePowerOfAtCached(
+      _owner: PromiseOrValue<BytesLike>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  filters: {
+    "VotePowerCacheCreated(bytes20,uint256)"(
+      nodeId?: null,
+      blockNumber?: null
+    ): VotePowerCacheCreatedEventFilter;
+    VotePowerCacheCreated(
+      nodeId?: null,
+      blockNumber?: null
+    ): VotePowerCacheCreatedEventFilter;
+
+    "VotePowerChanged(address,bytes20,uint256,uint256)"(
+      owner?: PromiseOrValue<string> | null,
+      nodeId?: PromiseOrValue<BytesLike> | null,
+      priorVotePower?: null,
+      newVotePower?: null
+    ): VotePowerChangedEventFilter;
+    VotePowerChanged(
+      owner?: PromiseOrValue<string> | null,
+      nodeId?: PromiseOrValue<BytesLike> | null,
+      priorVotePower?: null,
+      newVotePower?: null
+    ): VotePowerChangedEventFilter;
+  };
+
+  estimateGas: {
+    batchVotePowerOfAt(
+      _nodeIds: PromiseOrValue<BytesLike>[],
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    stakesOf(
+      _owner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    stakesOfAt(
+      _owner: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    totalVotePower(overrides?: CallOverrides): Promise<BigNumber>;
+
+    totalVotePowerAt(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    totalVotePowerAtCached(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    votePowerFromTo(
+      _owner: PromiseOrValue<string>,
+      _nodeId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    votePowerFromToAt(
+      _owner: PromiseOrValue<string>,
+      _nodeId: PromiseOrValue<BytesLike>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    votePowerOf(
+      _nodeId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    votePowerOfAt(
+      _nodeId: PromiseOrValue<BytesLike>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    votePowerOfAtCached(
+      _owner: PromiseOrValue<BytesLike>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    batchVotePowerOfAt(
+      _nodeIds: PromiseOrValue<BytesLike>[],
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    stakesOf(
+      _owner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    stakesOfAt(
+      _owner: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    totalVotePower(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    totalVotePowerAt(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    totalVotePowerAtCached(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    votePowerFromTo(
+      _owner: PromiseOrValue<string>,
+      _nodeId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    votePowerFromToAt(
+      _owner: PromiseOrValue<string>,
+      _nodeId: PromiseOrValue<BytesLike>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    votePowerOf(
+      _nodeId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    votePowerOfAt(
+      _nodeId: PromiseOrValue<BytesLike>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    votePowerOfAtCached(
+      _owner: PromiseOrValue<BytesLike>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IPollingFtso.ts

@@ -0,0 +1,784 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PayableOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export interface IPollingFtsoInterface extends utils.Interface {
+  functions: {
+    "canPropose(address)": FunctionFragment;
+    "canVote(address,uint256)": FunctionFragment;
+    "cancel(uint256)": FunctionFragment;
+    "castVote(uint256,uint8)": FunctionFragment;
+    "getLastProposal()": FunctionFragment;
+    "getProposalDescription(uint256)": FunctionFragment;
+    "getProposalInfo(uint256)": FunctionFragment;
+    "getProposalVotes(uint256)": FunctionFragment;
+    "hasVoted(uint256,address)": FunctionFragment;
+    "propose(string)": FunctionFragment;
+    "setParameters(uint256,uint256,uint256,uint256,uint256)": FunctionFragment;
+    "setProxyVoter(address)": FunctionFragment;
+    "state(uint256)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "canPropose"
+      | "canVote"
+      | "cancel"
+      | "castVote"
+      | "getLastProposal"
+      | "getProposalDescription"
+      | "getProposalInfo"
+      | "getProposalVotes"
+      | "hasVoted"
+      | "propose"
+      | "setParameters"
+      | "setProxyVoter"
+      | "state"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "canPropose",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "canVote",
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "cancel",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "castVote",
+    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getLastProposal",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getProposalDescription",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getProposalInfo",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getProposalVotes",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "hasVoted",
+    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "propose",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setParameters",
+    values: [
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setProxyVoter",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "state",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "canPropose", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "canVote", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "cancel", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "castVote", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getLastProposal",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getProposalDescription",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getProposalInfo",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getProposalVotes",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "hasVoted", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "propose", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "setParameters",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "setProxyVoter",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "state", data: BytesLike): Result;
+
+  events: {
+    "FtsoProposalCreated(uint256,uint256,address,string,uint256,uint256,uint256,uint256,uint256)": EventFragment;
+    "MaintainerSet(address)": EventFragment;
+    "ParametersSet(uint256,uint256,uint256,uint256,uint256)": EventFragment;
+    "ProposalCanceled(uint256)": EventFragment;
+    "ProxyVoterSet(address,address)": EventFragment;
+    "VoteCast(address,uint256,uint8,uint256,uint256)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "FtsoProposalCreated"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "MaintainerSet"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "ParametersSet"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "ProposalCanceled"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "ProxyVoterSet"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "VoteCast"): EventFragment;
+}
+
+export interface FtsoProposalCreatedEventObject {
+  proposalId: BigNumber;
+  rewardEpochId: BigNumber;
+  proposer: string;
+  description: string;
+  voteStartTime: BigNumber;
+  voteEndTime: BigNumber;
+  threshold: BigNumber;
+  majorityConditionBIPS: BigNumber;
+  totalWeight: BigNumber;
+}
+export type FtsoProposalCreatedEvent = TypedEvent<
+  [
+    BigNumber,
+    BigNumber,
+    string,
+    string,
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    BigNumber,
+    BigNumber
+  ],
+  FtsoProposalCreatedEventObject
+>;
+
+export type FtsoProposalCreatedEventFilter =
+  TypedEventFilter<FtsoProposalCreatedEvent>;
+
+export interface MaintainerSetEventObject {
+  newMaintainer: string;
+}
+export type MaintainerSetEvent = TypedEvent<[string], MaintainerSetEventObject>;
+
+export type MaintainerSetEventFilter = TypedEventFilter<MaintainerSetEvent>;
+
+export interface ParametersSetEventObject {
+  votingDelaySeconds: BigNumber;
+  votingPeriodSeconds: BigNumber;
+  thresholdConditionBIPS: BigNumber;
+  majorityConditionBIPS: BigNumber;
+  proposalFeeValueWei: BigNumber;
+}
+export type ParametersSetEvent = TypedEvent<
+  [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber],
+  ParametersSetEventObject
+>;
+
+export type ParametersSetEventFilter = TypedEventFilter<ParametersSetEvent>;
+
+export interface ProposalCanceledEventObject {
+  proposalId: BigNumber;
+}
+export type ProposalCanceledEvent = TypedEvent<
+  [BigNumber],
+  ProposalCanceledEventObject
+>;
+
+export type ProposalCanceledEventFilter =
+  TypedEventFilter<ProposalCanceledEvent>;
+
+export interface ProxyVoterSetEventObject {
+  account: string;
+  proxyVoter: string;
+}
+export type ProxyVoterSetEvent = TypedEvent<
+  [string, string],
+  ProxyVoterSetEventObject
+>;
+
+export type ProxyVoterSetEventFilter = TypedEventFilter<ProxyVoterSetEvent>;
+
+export interface VoteCastEventObject {
+  voter: string;
+  proposalId: BigNumber;
+  support: number;
+  forVotePower: BigNumber;
+  againstVotePower: BigNumber;
+}
+export type VoteCastEvent = TypedEvent<
+  [string, BigNumber, number, BigNumber, BigNumber],
+  VoteCastEventObject
+>;
+
+export type VoteCastEventFilter = TypedEventFilter<VoteCastEvent>;
+
+export interface IPollingFtso extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IPollingFtsoInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    canPropose(
+      _account: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[boolean]>;
+
+    canVote(
+      _account: PromiseOrValue<string>,
+      _proposalId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[boolean]>;
+
+    cancel(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    castVote(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      _support: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    getLastProposal(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, string] & { _proposalId: BigNumber; _description: string }
+    >;
+
+    getProposalDescription(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[string] & { _description: string }>;
+
+    getProposalInfo(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [
+        BigNumber,
+        string,
+        string,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber
+      ] & {
+        _rewardEpochId: BigNumber;
+        _description: string;
+        _proposer: string;
+        _voteStartTime: BigNumber;
+        _voteEndTime: BigNumber;
+        _thresholdConditionBIPS: BigNumber;
+        _majorityConditionBIPS: BigNumber;
+        _totalWeight: BigNumber;
+      }
+    >;
+
+    getProposalVotes(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { _for: BigNumber; _against: BigNumber }
+    >;
+
+    hasVoted(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[boolean]>;
+
+    propose(
+      _description: PromiseOrValue<string>,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    setParameters(
+      _votingDelaySeconds: PromiseOrValue<BigNumberish>,
+      _votingPeriodSeconds: PromiseOrValue<BigNumberish>,
+      _thresholdConditionBIPS: PromiseOrValue<BigNumberish>,
+      _majorityConditionBIPS: PromiseOrValue<BigNumberish>,
+      _proposalFeeValueWei: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    setProxyVoter(
+      _proxyVoter: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    state(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[number]>;
+  };
+
+  canPropose(
+    _account: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<boolean>;
+
+  canVote(
+    _account: PromiseOrValue<string>,
+    _proposalId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<boolean>;
+
+  cancel(
+    _proposalId: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  castVote(
+    _proposalId: PromiseOrValue<BigNumberish>,
+    _support: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  getLastProposal(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, string] & { _proposalId: BigNumber; _description: string }
+  >;
+
+  getProposalDescription(
+    _proposalId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  getProposalInfo(
+    _proposalId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<
+    [
+      BigNumber,
+      string,
+      string,
+      BigNumber,
+      BigNumber,
+      BigNumber,
+      BigNumber,
+      BigNumber
+    ] & {
+      _rewardEpochId: BigNumber;
+      _description: string;
+      _proposer: string;
+      _voteStartTime: BigNumber;
+      _voteEndTime: BigNumber;
+      _thresholdConditionBIPS: BigNumber;
+      _majorityConditionBIPS: BigNumber;
+      _totalWeight: BigNumber;
+    }
+  >;
+
+  getProposalVotes(
+    _proposalId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<[BigNumber, BigNumber] & { _for: BigNumber; _against: BigNumber }>;
+
+  hasVoted(
+    _proposalId: PromiseOrValue<BigNumberish>,
+    _voter: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<boolean>;
+
+  propose(
+    _description: PromiseOrValue<string>,
+    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  setParameters(
+    _votingDelaySeconds: PromiseOrValue<BigNumberish>,
+    _votingPeriodSeconds: PromiseOrValue<BigNumberish>,
+    _thresholdConditionBIPS: PromiseOrValue<BigNumberish>,
+    _majorityConditionBIPS: PromiseOrValue<BigNumberish>,
+    _proposalFeeValueWei: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  setProxyVoter(
+    _proxyVoter: PromiseOrValue<string>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  state(
+    _proposalId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<number>;
+
+  callStatic: {
+    canPropose(
+      _account: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    canVote(
+      _account: PromiseOrValue<string>,
+      _proposalId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    cancel(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    castVote(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      _support: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    getLastProposal(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, string] & { _proposalId: BigNumber; _description: string }
+    >;
+
+    getProposalDescription(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    getProposalInfo(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [
+        BigNumber,
+        string,
+        string,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber
+      ] & {
+        _rewardEpochId: BigNumber;
+        _description: string;
+        _proposer: string;
+        _voteStartTime: BigNumber;
+        _voteEndTime: BigNumber;
+        _thresholdConditionBIPS: BigNumber;
+        _majorityConditionBIPS: BigNumber;
+        _totalWeight: BigNumber;
+      }
+    >;
+
+    getProposalVotes(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { _for: BigNumber; _against: BigNumber }
+    >;
+
+    hasVoted(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    propose(
+      _description: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    setParameters(
+      _votingDelaySeconds: PromiseOrValue<BigNumberish>,
+      _votingPeriodSeconds: PromiseOrValue<BigNumberish>,
+      _thresholdConditionBIPS: PromiseOrValue<BigNumberish>,
+      _majorityConditionBIPS: PromiseOrValue<BigNumberish>,
+      _proposalFeeValueWei: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    setProxyVoter(
+      _proxyVoter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    state(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<number>;
+  };
+
+  filters: {
+    "FtsoProposalCreated(uint256,uint256,address,string,uint256,uint256,uint256,uint256,uint256)"(
+      proposalId?: PromiseOrValue<BigNumberish> | null,
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      proposer?: null,
+      description?: null,
+      voteStartTime?: null,
+      voteEndTime?: null,
+      threshold?: null,
+      majorityConditionBIPS?: null,
+      totalWeight?: null
+    ): FtsoProposalCreatedEventFilter;
+    FtsoProposalCreated(
+      proposalId?: PromiseOrValue<BigNumberish> | null,
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      proposer?: null,
+      description?: null,
+      voteStartTime?: null,
+      voteEndTime?: null,
+      threshold?: null,
+      majorityConditionBIPS?: null,
+      totalWeight?: null
+    ): FtsoProposalCreatedEventFilter;
+
+    "MaintainerSet(address)"(newMaintainer?: null): MaintainerSetEventFilter;
+    MaintainerSet(newMaintainer?: null): MaintainerSetEventFilter;
+
+    "ParametersSet(uint256,uint256,uint256,uint256,uint256)"(
+      votingDelaySeconds?: null,
+      votingPeriodSeconds?: null,
+      thresholdConditionBIPS?: null,
+      majorityConditionBIPS?: null,
+      proposalFeeValueWei?: null
+    ): ParametersSetEventFilter;
+    ParametersSet(
+      votingDelaySeconds?: null,
+      votingPeriodSeconds?: null,
+      thresholdConditionBIPS?: null,
+      majorityConditionBIPS?: null,
+      proposalFeeValueWei?: null
+    ): ParametersSetEventFilter;
+
+    "ProposalCanceled(uint256)"(
+      proposalId?: PromiseOrValue<BigNumberish> | null
+    ): ProposalCanceledEventFilter;
+    ProposalCanceled(
+      proposalId?: PromiseOrValue<BigNumberish> | null
+    ): ProposalCanceledEventFilter;
+
+    "ProxyVoterSet(address,address)"(
+      account?: null,
+      proxyVoter?: null
+    ): ProxyVoterSetEventFilter;
+    ProxyVoterSet(account?: null, proxyVoter?: null): ProxyVoterSetEventFilter;
+
+    "VoteCast(address,uint256,uint8,uint256,uint256)"(
+      voter?: PromiseOrValue<string> | null,
+      proposalId?: PromiseOrValue<BigNumberish> | null,
+      support?: null,
+      forVotePower?: null,
+      againstVotePower?: null
+    ): VoteCastEventFilter;
+    VoteCast(
+      voter?: PromiseOrValue<string> | null,
+      proposalId?: PromiseOrValue<BigNumberish> | null,
+      support?: null,
+      forVotePower?: null,
+      againstVotePower?: null
+    ): VoteCastEventFilter;
+  };
+
+  estimateGas: {
+    canPropose(
+      _account: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    canVote(
+      _account: PromiseOrValue<string>,
+      _proposalId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    cancel(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    castVote(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      _support: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    getLastProposal(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getProposalDescription(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getProposalInfo(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getProposalVotes(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    hasVoted(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    propose(
+      _description: PromiseOrValue<string>,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    setParameters(
+      _votingDelaySeconds: PromiseOrValue<BigNumberish>,
+      _votingPeriodSeconds: PromiseOrValue<BigNumberish>,
+      _thresholdConditionBIPS: PromiseOrValue<BigNumberish>,
+      _majorityConditionBIPS: PromiseOrValue<BigNumberish>,
+      _proposalFeeValueWei: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    setProxyVoter(
+      _proxyVoter: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    state(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    canPropose(
+      _account: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    canVote(
+      _account: PromiseOrValue<string>,
+      _proposalId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    cancel(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    castVote(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      _support: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    getLastProposal(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getProposalDescription(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getProposalInfo(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getProposalVotes(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    hasVoted(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    propose(
+      _description: PromiseOrValue<string>,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    setParameters(
+      _votingDelaySeconds: PromiseOrValue<BigNumberish>,
+      _votingPeriodSeconds: PromiseOrValue<BigNumberish>,
+      _thresholdConditionBIPS: PromiseOrValue<BigNumberish>,
+      _majorityConditionBIPS: PromiseOrValue<BigNumberish>,
+      _proposalFeeValueWei: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    setProxyVoter(
+      _proxyVoter: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    state(
+      _proposalId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IPriceSubmitter.ts

@@ -0,0 +1,383 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export interface IPriceSubmitterInterface extends utils.Interface {
+  functions: {
+    "getCurrentRandom()": FunctionFragment;
+    "getFtsoManager()": FunctionFragment;
+    "getFtsoRegistry()": FunctionFragment;
+    "getRandom(uint256)": FunctionFragment;
+    "getVoterWhitelister()": FunctionFragment;
+    "revealPrices(uint256,uint256[],uint256[],uint256)": FunctionFragment;
+    "submitHash(uint256,bytes32)": FunctionFragment;
+    "voterWhitelistBitmap(address)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "getCurrentRandom"
+      | "getFtsoManager"
+      | "getFtsoRegistry"
+      | "getRandom"
+      | "getVoterWhitelister"
+      | "revealPrices"
+      | "submitHash"
+      | "voterWhitelistBitmap"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "getCurrentRandom",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFtsoManager",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFtsoRegistry",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRandom",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getVoterWhitelister",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "revealPrices",
+    values: [
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>[],
+      PromiseOrValue<BigNumberish>[],
+      PromiseOrValue<BigNumberish>
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "submitHash",
+    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "voterWhitelistBitmap",
+    values: [PromiseOrValue<string>]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "getCurrentRandom",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getFtsoManager",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getFtsoRegistry",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getRandom", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getVoterWhitelister",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "revealPrices",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "submitHash", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "voterWhitelistBitmap",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "HashSubmitted(address,uint256,bytes32,uint256)": EventFragment;
+    "PricesRevealed(address,uint256,address[],uint256[],uint256,uint256)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "HashSubmitted"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "PricesRevealed"): EventFragment;
+}
+
+export interface HashSubmittedEventObject {
+  submitter: string;
+  epochId: BigNumber;
+  hash: string;
+  timestamp: BigNumber;
+}
+export type HashSubmittedEvent = TypedEvent<
+  [string, BigNumber, string, BigNumber],
+  HashSubmittedEventObject
+>;
+
+export type HashSubmittedEventFilter = TypedEventFilter<HashSubmittedEvent>;
+
+export interface PricesRevealedEventObject {
+  voter: string;
+  epochId: BigNumber;
+  ftsos: string[];
+  prices: BigNumber[];
+  random: BigNumber;
+  timestamp: BigNumber;
+}
+export type PricesRevealedEvent = TypedEvent<
+  [string, BigNumber, string[], BigNumber[], BigNumber, BigNumber],
+  PricesRevealedEventObject
+>;
+
+export type PricesRevealedEventFilter = TypedEventFilter<PricesRevealedEvent>;
+
+export interface IPriceSubmitter extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IPriceSubmitterInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    getCurrentRandom(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    getFtsoManager(overrides?: CallOverrides): Promise<[string]>;
+
+    getFtsoRegistry(overrides?: CallOverrides): Promise<[string]>;
+
+    getRandom(
+      _epochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    getVoterWhitelister(overrides?: CallOverrides): Promise<[string]>;
+
+    revealPrices(
+      _epochId: PromiseOrValue<BigNumberish>,
+      _ftsoIndices: PromiseOrValue<BigNumberish>[],
+      _prices: PromiseOrValue<BigNumberish>[],
+      _random: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    submitHash(
+      _epochId: PromiseOrValue<BigNumberish>,
+      _hash: PromiseOrValue<BytesLike>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    voterWhitelistBitmap(
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+  };
+
+  getCurrentRandom(overrides?: CallOverrides): Promise<BigNumber>;
+
+  getFtsoManager(overrides?: CallOverrides): Promise<string>;
+
+  getFtsoRegistry(overrides?: CallOverrides): Promise<string>;
+
+  getRandom(
+    _epochId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  getVoterWhitelister(overrides?: CallOverrides): Promise<string>;
+
+  revealPrices(
+    _epochId: PromiseOrValue<BigNumberish>,
+    _ftsoIndices: PromiseOrValue<BigNumberish>[],
+    _prices: PromiseOrValue<BigNumberish>[],
+    _random: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  submitHash(
+    _epochId: PromiseOrValue<BigNumberish>,
+    _hash: PromiseOrValue<BytesLike>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  voterWhitelistBitmap(
+    _voter: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  callStatic: {
+    getCurrentRandom(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getFtsoManager(overrides?: CallOverrides): Promise<string>;
+
+    getFtsoRegistry(overrides?: CallOverrides): Promise<string>;
+
+    getRandom(
+      _epochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getVoterWhitelister(overrides?: CallOverrides): Promise<string>;
+
+    revealPrices(
+      _epochId: PromiseOrValue<BigNumberish>,
+      _ftsoIndices: PromiseOrValue<BigNumberish>[],
+      _prices: PromiseOrValue<BigNumberish>[],
+      _random: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    submitHash(
+      _epochId: PromiseOrValue<BigNumberish>,
+      _hash: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    voterWhitelistBitmap(
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  filters: {
+    "HashSubmitted(address,uint256,bytes32,uint256)"(
+      submitter?: PromiseOrValue<string> | null,
+      epochId?: PromiseOrValue<BigNumberish> | null,
+      hash?: null,
+      timestamp?: null
+    ): HashSubmittedEventFilter;
+    HashSubmitted(
+      submitter?: PromiseOrValue<string> | null,
+      epochId?: PromiseOrValue<BigNumberish> | null,
+      hash?: null,
+      timestamp?: null
+    ): HashSubmittedEventFilter;
+
+    "PricesRevealed(address,uint256,address[],uint256[],uint256,uint256)"(
+      voter?: PromiseOrValue<string> | null,
+      epochId?: PromiseOrValue<BigNumberish> | null,
+      ftsos?: null,
+      prices?: null,
+      random?: null,
+      timestamp?: null
+    ): PricesRevealedEventFilter;
+    PricesRevealed(
+      voter?: PromiseOrValue<string> | null,
+      epochId?: PromiseOrValue<BigNumberish> | null,
+      ftsos?: null,
+      prices?: null,
+      random?: null,
+      timestamp?: null
+    ): PricesRevealedEventFilter;
+  };
+
+  estimateGas: {
+    getCurrentRandom(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getFtsoManager(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getFtsoRegistry(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getRandom(
+      _epochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getVoterWhitelister(overrides?: CallOverrides): Promise<BigNumber>;
+
+    revealPrices(
+      _epochId: PromiseOrValue<BigNumberish>,
+      _ftsoIndices: PromiseOrValue<BigNumberish>[],
+      _prices: PromiseOrValue<BigNumberish>[],
+      _random: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    submitHash(
+      _epochId: PromiseOrValue<BigNumberish>,
+      _hash: PromiseOrValue<BytesLike>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    voterWhitelistBitmap(
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    getCurrentRandom(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getFtsoManager(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getFtsoRegistry(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getRandom(
+      _epochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getVoterWhitelister(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    revealPrices(
+      _epochId: PromiseOrValue<BigNumberish>,
+      _ftsoIndices: PromiseOrValue<BigNumberish>[],
+      _prices: PromiseOrValue<BigNumberish>[],
+      _random: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    submitHash(
+      _epochId: PromiseOrValue<BigNumberish>,
+      _hash: PromiseOrValue<BytesLike>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    voterWhitelistBitmap(
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IRNatAccount.ts

@@ -0,0 +1,239 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "../../../common";
+
+export interface IRNatAccountInterface extends utils.Interface {
+  functions: {
+    "owner()": FunctionFragment;
+    "rNat()": FunctionFragment;
+    "receivedRewards()": FunctionFragment;
+    "withdrawnRewards()": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "owner"
+      | "rNat"
+      | "receivedRewards"
+      | "withdrawnRewards"
+  ): FunctionFragment;
+
+  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
+  encodeFunctionData(functionFragment: "rNat", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "receivedRewards",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "withdrawnRewards",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "rNat", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "receivedRewards",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "withdrawnRewards",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "ClaimExecutorsSet(address[])": EventFragment;
+    "ExternalTokenTransferred(address,uint256)": EventFragment;
+    "FundsWithdrawn(uint256,bool)": EventFragment;
+    "Initialized(address,address)": EventFragment;
+    "LockedAmountBurned(uint256)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "ClaimExecutorsSet"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "ExternalTokenTransferred"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "FundsWithdrawn"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "LockedAmountBurned"): EventFragment;
+}
+
+export interface ClaimExecutorsSetEventObject {
+  executors: string[];
+}
+export type ClaimExecutorsSetEvent = TypedEvent<
+  [string[]],
+  ClaimExecutorsSetEventObject
+>;
+
+export type ClaimExecutorsSetEventFilter =
+  TypedEventFilter<ClaimExecutorsSetEvent>;
+
+export interface ExternalTokenTransferredEventObject {
+  token: string;
+  amount: BigNumber;
+}
+export type ExternalTokenTransferredEvent = TypedEvent<
+  [string, BigNumber],
+  ExternalTokenTransferredEventObject
+>;
+
+export type ExternalTokenTransferredEventFilter =
+  TypedEventFilter<ExternalTokenTransferredEvent>;
+
+export interface FundsWithdrawnEventObject {
+  amount: BigNumber;
+  wrap: boolean;
+}
+export type FundsWithdrawnEvent = TypedEvent<
+  [BigNumber, boolean],
+  FundsWithdrawnEventObject
+>;
+
+export type FundsWithdrawnEventFilter = TypedEventFilter<FundsWithdrawnEvent>;
+
+export interface InitializedEventObject {
+  owner: string;
+  rNat: string;
+}
+export type InitializedEvent = TypedEvent<
+  [string, string],
+  InitializedEventObject
+>;
+
+export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
+
+export interface LockedAmountBurnedEventObject {
+  amount: BigNumber;
+}
+export type LockedAmountBurnedEvent = TypedEvent<
+  [BigNumber],
+  LockedAmountBurnedEventObject
+>;
+
+export type LockedAmountBurnedEventFilter =
+  TypedEventFilter<LockedAmountBurnedEvent>;
+
+export interface IRNatAccount extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IRNatAccountInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    owner(overrides?: CallOverrides): Promise<[string]>;
+
+    rNat(overrides?: CallOverrides): Promise<[string]>;
+
+    receivedRewards(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    withdrawnRewards(overrides?: CallOverrides): Promise<[BigNumber]>;
+  };
+
+  owner(overrides?: CallOverrides): Promise<string>;
+
+  rNat(overrides?: CallOverrides): Promise<string>;
+
+  receivedRewards(overrides?: CallOverrides): Promise<BigNumber>;
+
+  withdrawnRewards(overrides?: CallOverrides): Promise<BigNumber>;
+
+  callStatic: {
+    owner(overrides?: CallOverrides): Promise<string>;
+
+    rNat(overrides?: CallOverrides): Promise<string>;
+
+    receivedRewards(overrides?: CallOverrides): Promise<BigNumber>;
+
+    withdrawnRewards(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  filters: {
+    "ClaimExecutorsSet(address[])"(
+      executors?: null
+    ): ClaimExecutorsSetEventFilter;
+    ClaimExecutorsSet(executors?: null): ClaimExecutorsSetEventFilter;
+
+    "ExternalTokenTransferred(address,uint256)"(
+      token?: null,
+      amount?: null
+    ): ExternalTokenTransferredEventFilter;
+    ExternalTokenTransferred(
+      token?: null,
+      amount?: null
+    ): ExternalTokenTransferredEventFilter;
+
+    "FundsWithdrawn(uint256,bool)"(
+      amount?: null,
+      wrap?: null
+    ): FundsWithdrawnEventFilter;
+    FundsWithdrawn(amount?: null, wrap?: null): FundsWithdrawnEventFilter;
+
+    "Initialized(address,address)"(
+      owner?: null,
+      rNat?: null
+    ): InitializedEventFilter;
+    Initialized(owner?: null, rNat?: null): InitializedEventFilter;
+
+    "LockedAmountBurned(uint256)"(amount?: null): LockedAmountBurnedEventFilter;
+    LockedAmountBurned(amount?: null): LockedAmountBurnedEventFilter;
+  };
+
+  estimateGas: {
+    owner(overrides?: CallOverrides): Promise<BigNumber>;
+
+    rNat(overrides?: CallOverrides): Promise<BigNumber>;
+
+    receivedRewards(overrides?: CallOverrides): Promise<BigNumber>;
+
+    withdrawnRewards(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    rNat(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    receivedRewards(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    withdrawnRewards(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IRandomProvider.ts

@@ -0,0 +1,183 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "../../../common";
+
+export interface IRandomProviderInterface extends utils.Interface {
+  functions: {
+    "getCurrentRandom()": FunctionFragment;
+    "getCurrentRandomWithQuality()": FunctionFragment;
+    "getCurrentRandomWithQualityAndTimestamp()": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "getCurrentRandom"
+      | "getCurrentRandomWithQuality"
+      | "getCurrentRandomWithQualityAndTimestamp"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "getCurrentRandom",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentRandomWithQuality",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentRandomWithQualityAndTimestamp",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "getCurrentRandom",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentRandomWithQuality",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentRandomWithQualityAndTimestamp",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface IRandomProvider extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IRandomProviderInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    getCurrentRandom(
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { _randomNumber: BigNumber }>;
+
+    getCurrentRandomWithQuality(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, boolean] & {
+        _randomNumber: BigNumber;
+        _isSecureRandom: boolean;
+      }
+    >;
+
+    getCurrentRandomWithQualityAndTimestamp(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, boolean, BigNumber] & {
+        _randomNumber: BigNumber;
+        _isSecureRandom: boolean;
+        _randomTimestamp: BigNumber;
+      }
+    >;
+  };
+
+  getCurrentRandom(overrides?: CallOverrides): Promise<BigNumber>;
+
+  getCurrentRandomWithQuality(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, boolean] & {
+      _randomNumber: BigNumber;
+      _isSecureRandom: boolean;
+    }
+  >;
+
+  getCurrentRandomWithQualityAndTimestamp(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, boolean, BigNumber] & {
+      _randomNumber: BigNumber;
+      _isSecureRandom: boolean;
+      _randomTimestamp: BigNumber;
+    }
+  >;
+
+  callStatic: {
+    getCurrentRandom(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentRandomWithQuality(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, boolean] & {
+        _randomNumber: BigNumber;
+        _isSecureRandom: boolean;
+      }
+    >;
+
+    getCurrentRandomWithQualityAndTimestamp(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, boolean, BigNumber] & {
+        _randomNumber: BigNumber;
+        _isSecureRandom: boolean;
+        _randomTimestamp: BigNumber;
+      }
+    >;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    getCurrentRandom(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentRandomWithQuality(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentRandomWithQualityAndTimestamp(
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    getCurrentRandom(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getCurrentRandomWithQuality(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getCurrentRandomWithQualityAndTimestamp(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IRelay.ts

@@ -0,0 +1,737 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PayableOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export declare namespace IRelay {
+  export type FeeConfigStruct = {
+    protocolId: PromiseOrValue<BigNumberish>;
+    feeInWei: PromiseOrValue<BigNumberish>;
+  };
+
+  export type FeeConfigStructOutput = [number, BigNumber] & {
+    protocolId: number;
+    feeInWei: BigNumber;
+  };
+
+  export type RelayGovernanceConfigStruct = {
+    descriptionHash: PromiseOrValue<BytesLike>;
+    chainId: PromiseOrValue<BigNumberish>;
+    newFeeConfigs: IRelay.FeeConfigStruct[];
+  };
+
+  export type RelayGovernanceConfigStructOutput = [
+    string,
+    BigNumber,
+    IRelay.FeeConfigStructOutput[]
+  ] & {
+    descriptionHash: string;
+    chainId: BigNumber;
+    newFeeConfigs: IRelay.FeeConfigStructOutput[];
+  };
+}
+
+export interface IRelayInterface extends utils.Interface {
+  functions: {
+    "feeCollectionAddress()": FunctionFragment;
+    "getRandomNumber()": FunctionFragment;
+    "getRandomNumberHistorical(uint256)": FunctionFragment;
+    "getVotingRoundId(uint256)": FunctionFragment;
+    "governanceFeeSetup(bytes,(bytes32,uint256,(uint8,uint256)[]))": FunctionFragment;
+    "isFinalized(uint256,uint256)": FunctionFragment;
+    "lastInitializedRewardEpochData()": FunctionFragment;
+    "merkleRoots(uint256,uint256)": FunctionFragment;
+    "protocolFeeInWei(uint256)": FunctionFragment;
+    "relay()": FunctionFragment;
+    "startingVotingRoundIds(uint256)": FunctionFragment;
+    "toSigningPolicyHash(uint256)": FunctionFragment;
+    "verify(uint256,uint256,bytes32,bytes32[])": FunctionFragment;
+    "verifyCustomSignature(bytes,bytes32)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "feeCollectionAddress"
+      | "getRandomNumber"
+      | "getRandomNumberHistorical"
+      | "getVotingRoundId"
+      | "governanceFeeSetup"
+      | "isFinalized"
+      | "lastInitializedRewardEpochData"
+      | "merkleRoots"
+      | "protocolFeeInWei"
+      | "relay"
+      | "startingVotingRoundIds"
+      | "toSigningPolicyHash"
+      | "verify"
+      | "verifyCustomSignature"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "feeCollectionAddress",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRandomNumber",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRandomNumberHistorical",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getVotingRoundId",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "governanceFeeSetup",
+    values: [PromiseOrValue<BytesLike>, IRelay.RelayGovernanceConfigStruct]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isFinalized",
+    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "lastInitializedRewardEpochData",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "merkleRoots",
+    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "protocolFeeInWei",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(functionFragment: "relay", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "startingVotingRoundIds",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "toSigningPolicyHash",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "verify",
+    values: [
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BytesLike>,
+      PromiseOrValue<BytesLike>[]
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "verifyCustomSignature",
+    values: [PromiseOrValue<BytesLike>, PromiseOrValue<BytesLike>]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "feeCollectionAddress",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRandomNumber",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRandomNumberHistorical",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getVotingRoundId",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "governanceFeeSetup",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "isFinalized",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "lastInitializedRewardEpochData",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "merkleRoots",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "protocolFeeInWei",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "relay", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "startingVotingRoundIds",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "toSigningPolicyHash",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "verify", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "verifyCustomSignature",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "ProtocolMessageRelayed(uint8,uint32,bool,bytes32)": EventFragment;
+    "SigningPolicyInitialized(uint24,uint32,uint16,uint256,address[],uint16[],bytes,uint64)": EventFragment;
+    "SigningPolicyRelayed(uint256)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "ProtocolMessageRelayed"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "SigningPolicyInitialized"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "SigningPolicyRelayed"): EventFragment;
+}
+
+export interface ProtocolMessageRelayedEventObject {
+  protocolId: number;
+  votingRoundId: number;
+  isSecureRandom: boolean;
+  merkleRoot: string;
+}
+export type ProtocolMessageRelayedEvent = TypedEvent<
+  [number, number, boolean, string],
+  ProtocolMessageRelayedEventObject
+>;
+
+export type ProtocolMessageRelayedEventFilter =
+  TypedEventFilter<ProtocolMessageRelayedEvent>;
+
+export interface SigningPolicyInitializedEventObject {
+  rewardEpochId: number;
+  startVotingRoundId: number;
+  threshold: number;
+  seed: BigNumber;
+  voters: string[];
+  weights: number[];
+  signingPolicyBytes: string;
+  timestamp: BigNumber;
+}
+export type SigningPolicyInitializedEvent = TypedEvent<
+  [number, number, number, BigNumber, string[], number[], string, BigNumber],
+  SigningPolicyInitializedEventObject
+>;
+
+export type SigningPolicyInitializedEventFilter =
+  TypedEventFilter<SigningPolicyInitializedEvent>;
+
+export interface SigningPolicyRelayedEventObject {
+  rewardEpochId: BigNumber;
+}
+export type SigningPolicyRelayedEvent = TypedEvent<
+  [BigNumber],
+  SigningPolicyRelayedEventObject
+>;
+
+export type SigningPolicyRelayedEventFilter =
+  TypedEventFilter<SigningPolicyRelayedEvent>;
+
+export interface IRelay extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IRelayInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    feeCollectionAddress(overrides?: CallOverrides): Promise<[string]>;
+
+    getRandomNumber(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, boolean, BigNumber] & {
+        _randomNumber: BigNumber;
+        _isSecureRandom: boolean;
+        _randomTimestamp: BigNumber;
+      }
+    >;
+
+    getRandomNumberHistorical(
+      _votingRoundId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, boolean, BigNumber] & {
+        _randomNumber: BigNumber;
+        _isSecureRandom: boolean;
+        _randomTimestamp: BigNumber;
+      }
+    >;
+
+    getVotingRoundId(
+      _timestamp: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { _votingRoundId: BigNumber }>;
+
+    governanceFeeSetup(
+      _relayMessage: PromiseOrValue<BytesLike>,
+      _config: IRelay.RelayGovernanceConfigStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    isFinalized(
+      _protocolId: PromiseOrValue<BigNumberish>,
+      _votingRoundId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[boolean]>;
+
+    lastInitializedRewardEpochData(
+      overrides?: CallOverrides
+    ): Promise<
+      [number, number] & {
+        _lastInitializedRewardEpoch: number;
+        _startingVotingRoundIdForLastInitializedRewardEpoch: number;
+      }
+    >;
+
+    merkleRoots(
+      _protocolId: PromiseOrValue<BigNumberish>,
+      _votingRoundId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[string] & { _merkleRoot: string }>;
+
+    protocolFeeInWei(
+      _protocolId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    relay(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    startingVotingRoundIds(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { _startingVotingRoundId: BigNumber }>;
+
+    toSigningPolicyHash(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[string] & { _signingPolicyHash: string }>;
+
+    verify(
+      _protocolId: PromiseOrValue<BigNumberish>,
+      _votingRoundId: PromiseOrValue<BigNumberish>,
+      _leaf: PromiseOrValue<BytesLike>,
+      _proof: PromiseOrValue<BytesLike>[],
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    verifyCustomSignature(
+      _relayMessage: PromiseOrValue<BytesLike>,
+      _messageHash: PromiseOrValue<BytesLike>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  feeCollectionAddress(overrides?: CallOverrides): Promise<string>;
+
+  getRandomNumber(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, boolean, BigNumber] & {
+      _randomNumber: BigNumber;
+      _isSecureRandom: boolean;
+      _randomTimestamp: BigNumber;
+    }
+  >;
+
+  getRandomNumberHistorical(
+    _votingRoundId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, boolean, BigNumber] & {
+      _randomNumber: BigNumber;
+      _isSecureRandom: boolean;
+      _randomTimestamp: BigNumber;
+    }
+  >;
+
+  getVotingRoundId(
+    _timestamp: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  governanceFeeSetup(
+    _relayMessage: PromiseOrValue<BytesLike>,
+    _config: IRelay.RelayGovernanceConfigStruct,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  isFinalized(
+    _protocolId: PromiseOrValue<BigNumberish>,
+    _votingRoundId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<boolean>;
+
+  lastInitializedRewardEpochData(
+    overrides?: CallOverrides
+  ): Promise<
+    [number, number] & {
+      _lastInitializedRewardEpoch: number;
+      _startingVotingRoundIdForLastInitializedRewardEpoch: number;
+    }
+  >;
+
+  merkleRoots(
+    _protocolId: PromiseOrValue<BigNumberish>,
+    _votingRoundId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  protocolFeeInWei(
+    _protocolId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  relay(
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  startingVotingRoundIds(
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  toSigningPolicyHash(
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  verify(
+    _protocolId: PromiseOrValue<BigNumberish>,
+    _votingRoundId: PromiseOrValue<BigNumberish>,
+    _leaf: PromiseOrValue<BytesLike>,
+    _proof: PromiseOrValue<BytesLike>[],
+    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  verifyCustomSignature(
+    _relayMessage: PromiseOrValue<BytesLike>,
+    _messageHash: PromiseOrValue<BytesLike>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    feeCollectionAddress(overrides?: CallOverrides): Promise<string>;
+
+    getRandomNumber(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, boolean, BigNumber] & {
+        _randomNumber: BigNumber;
+        _isSecureRandom: boolean;
+        _randomTimestamp: BigNumber;
+      }
+    >;
+
+    getRandomNumberHistorical(
+      _votingRoundId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, boolean, BigNumber] & {
+        _randomNumber: BigNumber;
+        _isSecureRandom: boolean;
+        _randomTimestamp: BigNumber;
+      }
+    >;
+
+    getVotingRoundId(
+      _timestamp: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    governanceFeeSetup(
+      _relayMessage: PromiseOrValue<BytesLike>,
+      _config: IRelay.RelayGovernanceConfigStruct,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    isFinalized(
+      _protocolId: PromiseOrValue<BigNumberish>,
+      _votingRoundId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    lastInitializedRewardEpochData(
+      overrides?: CallOverrides
+    ): Promise<
+      [number, number] & {
+        _lastInitializedRewardEpoch: number;
+        _startingVotingRoundIdForLastInitializedRewardEpoch: number;
+      }
+    >;
+
+    merkleRoots(
+      _protocolId: PromiseOrValue<BigNumberish>,
+      _votingRoundId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    protocolFeeInWei(
+      _protocolId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    relay(overrides?: CallOverrides): Promise<string>;
+
+    startingVotingRoundIds(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    toSigningPolicyHash(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    verify(
+      _protocolId: PromiseOrValue<BigNumberish>,
+      _votingRoundId: PromiseOrValue<BigNumberish>,
+      _leaf: PromiseOrValue<BytesLike>,
+      _proof: PromiseOrValue<BytesLike>[],
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    verifyCustomSignature(
+      _relayMessage: PromiseOrValue<BytesLike>,
+      _messageHash: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  filters: {
+    "ProtocolMessageRelayed(uint8,uint32,bool,bytes32)"(
+      protocolId?: PromiseOrValue<BigNumberish> | null,
+      votingRoundId?: PromiseOrValue<BigNumberish> | null,
+      isSecureRandom?: null,
+      merkleRoot?: null
+    ): ProtocolMessageRelayedEventFilter;
+    ProtocolMessageRelayed(
+      protocolId?: PromiseOrValue<BigNumberish> | null,
+      votingRoundId?: PromiseOrValue<BigNumberish> | null,
+      isSecureRandom?: null,
+      merkleRoot?: null
+    ): ProtocolMessageRelayedEventFilter;
+
+    "SigningPolicyInitialized(uint24,uint32,uint16,uint256,address[],uint16[],bytes,uint64)"(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      startVotingRoundId?: null,
+      threshold?: null,
+      seed?: null,
+      voters?: null,
+      weights?: null,
+      signingPolicyBytes?: null,
+      timestamp?: null
+    ): SigningPolicyInitializedEventFilter;
+    SigningPolicyInitialized(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      startVotingRoundId?: null,
+      threshold?: null,
+      seed?: null,
+      voters?: null,
+      weights?: null,
+      signingPolicyBytes?: null,
+      timestamp?: null
+    ): SigningPolicyInitializedEventFilter;
+
+    "SigningPolicyRelayed(uint256)"(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null
+    ): SigningPolicyRelayedEventFilter;
+    SigningPolicyRelayed(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null
+    ): SigningPolicyRelayedEventFilter;
+  };
+
+  estimateGas: {
+    feeCollectionAddress(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getRandomNumber(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getRandomNumberHistorical(
+      _votingRoundId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getVotingRoundId(
+      _timestamp: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    governanceFeeSetup(
+      _relayMessage: PromiseOrValue<BytesLike>,
+      _config: IRelay.RelayGovernanceConfigStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    isFinalized(
+      _protocolId: PromiseOrValue<BigNumberish>,
+      _votingRoundId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    lastInitializedRewardEpochData(
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    merkleRoots(
+      _protocolId: PromiseOrValue<BigNumberish>,
+      _votingRoundId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    protocolFeeInWei(
+      _protocolId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    relay(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    startingVotingRoundIds(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    toSigningPolicyHash(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    verify(
+      _protocolId: PromiseOrValue<BigNumberish>,
+      _votingRoundId: PromiseOrValue<BigNumberish>,
+      _leaf: PromiseOrValue<BytesLike>,
+      _proof: PromiseOrValue<BytesLike>[],
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    verifyCustomSignature(
+      _relayMessage: PromiseOrValue<BytesLike>,
+      _messageHash: PromiseOrValue<BytesLike>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    feeCollectionAddress(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getRandomNumber(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getRandomNumberHistorical(
+      _votingRoundId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getVotingRoundId(
+      _timestamp: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    governanceFeeSetup(
+      _relayMessage: PromiseOrValue<BytesLike>,
+      _config: IRelay.RelayGovernanceConfigStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    isFinalized(
+      _protocolId: PromiseOrValue<BigNumberish>,
+      _votingRoundId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    lastInitializedRewardEpochData(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    merkleRoots(
+      _protocolId: PromiseOrValue<BigNumberish>,
+      _votingRoundId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    protocolFeeInWei(
+      _protocolId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    relay(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    startingVotingRoundIds(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    toSigningPolicyHash(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    verify(
+      _protocolId: PromiseOrValue<BigNumberish>,
+      _votingRoundId: PromiseOrValue<BigNumberish>,
+      _leaf: PromiseOrValue<BytesLike>,
+      _proof: PromiseOrValue<BytesLike>[],
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    verifyCustomSignature(
+      _relayMessage: PromiseOrValue<BytesLike>,
+      _messageHash: PromiseOrValue<BytesLike>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IRewardManager.ts

@@ -0,0 +1,824 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export declare namespace RewardsV2Interface {
+  export type RewardClaimStruct = {
+    rewardEpochId: PromiseOrValue<BigNumberish>;
+    beneficiary: PromiseOrValue<BytesLike>;
+    amount: PromiseOrValue<BigNumberish>;
+    claimType: PromiseOrValue<BigNumberish>;
+  };
+
+  export type RewardClaimStructOutput = [number, string, BigNumber, number] & {
+    rewardEpochId: number;
+    beneficiary: string;
+    amount: BigNumber;
+    claimType: number;
+  };
+
+  export type RewardClaimWithProofStruct = {
+    merkleProof: PromiseOrValue<BytesLike>[];
+    body: RewardsV2Interface.RewardClaimStruct;
+  };
+
+  export type RewardClaimWithProofStructOutput = [
+    string[],
+    RewardsV2Interface.RewardClaimStructOutput
+  ] & {
+    merkleProof: string[];
+    body: RewardsV2Interface.RewardClaimStructOutput;
+  };
+
+  export type RewardStateStruct = {
+    rewardEpochId: PromiseOrValue<BigNumberish>;
+    beneficiary: PromiseOrValue<BytesLike>;
+    amount: PromiseOrValue<BigNumberish>;
+    claimType: PromiseOrValue<BigNumberish>;
+    initialised: PromiseOrValue<boolean>;
+  };
+
+  export type RewardStateStructOutput = [
+    number,
+    string,
+    BigNumber,
+    number,
+    boolean
+  ] & {
+    rewardEpochId: number;
+    beneficiary: string;
+    amount: BigNumber;
+    claimType: number;
+    initialised: boolean;
+  };
+}
+
+export declare namespace IRewardManager {
+  export type UnclaimedRewardStateStruct = {
+    initialised: PromiseOrValue<boolean>;
+    amount: PromiseOrValue<BigNumberish>;
+    weight: PromiseOrValue<BigNumberish>;
+  };
+
+  export type UnclaimedRewardStateStructOutput = [
+    boolean,
+    BigNumber,
+    BigNumber
+  ] & { initialised: boolean; amount: BigNumber; weight: BigNumber };
+}
+
+export interface IRewardManagerInterface extends utils.Interface {
+  functions: {
+    "active()": FunctionFragment;
+    "autoClaim(address[],uint24,(bytes32[],(uint24,bytes20,uint120,uint8))[])": FunctionFragment;
+    "claim(address,address,uint24,bool,(bytes32[],(uint24,bytes20,uint120,uint8))[])": FunctionFragment;
+    "cleanupBlockNumber()": FunctionFragment;
+    "firstClaimableRewardEpochId()": FunctionFragment;
+    "getCurrentRewardEpochId()": FunctionFragment;
+    "getInitialRewardEpochId()": FunctionFragment;
+    "getNextClaimableRewardEpochId(address)": FunctionFragment;
+    "getRewardEpochIdToExpireNext()": FunctionFragment;
+    "getRewardEpochIdsWithClaimableRewards()": FunctionFragment;
+    "getRewardEpochTotals(uint24)": FunctionFragment;
+    "getStateOfRewards(address)": FunctionFragment;
+    "getStateOfRewardsAt(address,uint24)": FunctionFragment;
+    "getTotals()": FunctionFragment;
+    "getUnclaimedRewardState(address,uint24,uint8)": FunctionFragment;
+    "initialiseWeightBasedClaims((bytes32[],(uint24,bytes20,uint120,uint8))[])": FunctionFragment;
+    "noOfInitialisedWeightBasedClaims(uint256)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "active"
+      | "autoClaim"
+      | "claim"
+      | "cleanupBlockNumber"
+      | "firstClaimableRewardEpochId"
+      | "getCurrentRewardEpochId"
+      | "getInitialRewardEpochId"
+      | "getNextClaimableRewardEpochId"
+      | "getRewardEpochIdToExpireNext"
+      | "getRewardEpochIdsWithClaimableRewards"
+      | "getRewardEpochTotals"
+      | "getStateOfRewards"
+      | "getStateOfRewardsAt"
+      | "getTotals"
+      | "getUnclaimedRewardState"
+      | "initialiseWeightBasedClaims"
+      | "noOfInitialisedWeightBasedClaims"
+  ): FunctionFragment;
+
+  encodeFunctionData(functionFragment: "active", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "autoClaim",
+    values: [
+      PromiseOrValue<string>[],
+      PromiseOrValue<BigNumberish>,
+      RewardsV2Interface.RewardClaimWithProofStruct[]
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "claim",
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<boolean>,
+      RewardsV2Interface.RewardClaimWithProofStruct[]
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "cleanupBlockNumber",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "firstClaimableRewardEpochId",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentRewardEpochId",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getInitialRewardEpochId",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getNextClaimableRewardEpochId",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRewardEpochIdToExpireNext",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRewardEpochIdsWithClaimableRewards",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRewardEpochTotals",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getStateOfRewards",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getStateOfRewardsAt",
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(functionFragment: "getTotals", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "getUnclaimedRewardState",
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "initialiseWeightBasedClaims",
+    values: [RewardsV2Interface.RewardClaimWithProofStruct[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "noOfInitialisedWeightBasedClaims",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "active", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "autoClaim", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "claim", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "cleanupBlockNumber",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "firstClaimableRewardEpochId",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentRewardEpochId",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getInitialRewardEpochId",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getNextClaimableRewardEpochId",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRewardEpochIdToExpireNext",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRewardEpochIdsWithClaimableRewards",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRewardEpochTotals",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getStateOfRewards",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getStateOfRewardsAt",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getTotals", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getUnclaimedRewardState",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "initialiseWeightBasedClaims",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "noOfInitialisedWeightBasedClaims",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "RewardClaimed(address,address,address,uint24,uint8,uint120)": EventFragment;
+    "RewardClaimsEnabled(uint256)": EventFragment;
+    "RewardClaimsExpired(uint256)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "RewardClaimed"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "RewardClaimsEnabled"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "RewardClaimsExpired"): EventFragment;
+}
+
+export interface RewardClaimedEventObject {
+  beneficiary: string;
+  rewardOwner: string;
+  recipient: string;
+  rewardEpochId: number;
+  claimType: number;
+  amount: BigNumber;
+}
+export type RewardClaimedEvent = TypedEvent<
+  [string, string, string, number, number, BigNumber],
+  RewardClaimedEventObject
+>;
+
+export type RewardClaimedEventFilter = TypedEventFilter<RewardClaimedEvent>;
+
+export interface RewardClaimsEnabledEventObject {
+  rewardEpochId: BigNumber;
+}
+export type RewardClaimsEnabledEvent = TypedEvent<
+  [BigNumber],
+  RewardClaimsEnabledEventObject
+>;
+
+export type RewardClaimsEnabledEventFilter =
+  TypedEventFilter<RewardClaimsEnabledEvent>;
+
+export interface RewardClaimsExpiredEventObject {
+  rewardEpochId: BigNumber;
+}
+export type RewardClaimsExpiredEvent = TypedEvent<
+  [BigNumber],
+  RewardClaimsExpiredEventObject
+>;
+
+export type RewardClaimsExpiredEventFilter =
+  TypedEventFilter<RewardClaimsExpiredEvent>;
+
+export interface IRewardManager extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IRewardManagerInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    active(overrides?: CallOverrides): Promise<[boolean]>;
+
+    autoClaim(
+      _rewardOwners: PromiseOrValue<string>[],
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _proofs: RewardsV2Interface.RewardClaimWithProofStruct[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    claim(
+      _rewardOwner: PromiseOrValue<string>,
+      _recipient: PromiseOrValue<string>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _wrap: PromiseOrValue<boolean>,
+      _proofs: RewardsV2Interface.RewardClaimWithProofStruct[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    cleanupBlockNumber(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    firstClaimableRewardEpochId(overrides?: CallOverrides): Promise<[number]>;
+
+    getCurrentRewardEpochId(overrides?: CallOverrides): Promise<[number]>;
+
+    getInitialRewardEpochId(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    getNextClaimableRewardEpochId(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    getRewardEpochIdToExpireNext(
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    getRewardEpochIdsWithClaimableRewards(
+      overrides?: CallOverrides
+    ): Promise<
+      [number, number] & { _startEpochId: number; _endEpochId: number }
+    >;
+
+    getRewardEpochTotals(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+        _totalRewardsWei: BigNumber;
+        _totalInflationRewardsWei: BigNumber;
+        _initialisedRewardsWei: BigNumber;
+        _claimedRewardsWei: BigNumber;
+        _burnedRewardsWei: BigNumber;
+      }
+    >;
+
+    getStateOfRewards(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<
+      [RewardsV2Interface.RewardStateStructOutput[][]] & {
+        _rewardStates: RewardsV2Interface.RewardStateStructOutput[][];
+      }
+    >;
+
+    getStateOfRewardsAt(
+      _rewardOwner: PromiseOrValue<string>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [RewardsV2Interface.RewardStateStructOutput[]] & {
+        _rewardStates: RewardsV2Interface.RewardStateStructOutput[];
+      }
+    >;
+
+    getTotals(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber] & {
+        _totalRewardsWei: BigNumber;
+        _totalInflationRewardsWei: BigNumber;
+        _totalClaimedWei: BigNumber;
+        _totalBurnedWei: BigNumber;
+      }
+    >;
+
+    getUnclaimedRewardState(
+      _beneficiary: PromiseOrValue<string>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _claimType: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [IRewardManager.UnclaimedRewardStateStructOutput] & {
+        _state: IRewardManager.UnclaimedRewardStateStructOutput;
+      }
+    >;
+
+    initialiseWeightBasedClaims(
+      _proofs: RewardsV2Interface.RewardClaimWithProofStruct[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    noOfInitialisedWeightBasedClaims(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+  };
+
+  active(overrides?: CallOverrides): Promise<boolean>;
+
+  autoClaim(
+    _rewardOwners: PromiseOrValue<string>[],
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    _proofs: RewardsV2Interface.RewardClaimWithProofStruct[],
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  claim(
+    _rewardOwner: PromiseOrValue<string>,
+    _recipient: PromiseOrValue<string>,
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    _wrap: PromiseOrValue<boolean>,
+    _proofs: RewardsV2Interface.RewardClaimWithProofStruct[],
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  cleanupBlockNumber(overrides?: CallOverrides): Promise<BigNumber>;
+
+  firstClaimableRewardEpochId(overrides?: CallOverrides): Promise<number>;
+
+  getCurrentRewardEpochId(overrides?: CallOverrides): Promise<number>;
+
+  getInitialRewardEpochId(overrides?: CallOverrides): Promise<BigNumber>;
+
+  getNextClaimableRewardEpochId(
+    _rewardOwner: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  getRewardEpochIdToExpireNext(overrides?: CallOverrides): Promise<BigNumber>;
+
+  getRewardEpochIdsWithClaimableRewards(
+    overrides?: CallOverrides
+  ): Promise<[number, number] & { _startEpochId: number; _endEpochId: number }>;
+
+  getRewardEpochTotals(
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+      _totalRewardsWei: BigNumber;
+      _totalInflationRewardsWei: BigNumber;
+      _initialisedRewardsWei: BigNumber;
+      _claimedRewardsWei: BigNumber;
+      _burnedRewardsWei: BigNumber;
+    }
+  >;
+
+  getStateOfRewards(
+    _rewardOwner: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<RewardsV2Interface.RewardStateStructOutput[][]>;
+
+  getStateOfRewardsAt(
+    _rewardOwner: PromiseOrValue<string>,
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<RewardsV2Interface.RewardStateStructOutput[]>;
+
+  getTotals(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, BigNumber, BigNumber] & {
+      _totalRewardsWei: BigNumber;
+      _totalInflationRewardsWei: BigNumber;
+      _totalClaimedWei: BigNumber;
+      _totalBurnedWei: BigNumber;
+    }
+  >;
+
+  getUnclaimedRewardState(
+    _beneficiary: PromiseOrValue<string>,
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    _claimType: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<IRewardManager.UnclaimedRewardStateStructOutput>;
+
+  initialiseWeightBasedClaims(
+    _proofs: RewardsV2Interface.RewardClaimWithProofStruct[],
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  noOfInitialisedWeightBasedClaims(
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  callStatic: {
+    active(overrides?: CallOverrides): Promise<boolean>;
+
+    autoClaim(
+      _rewardOwners: PromiseOrValue<string>[],
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _proofs: RewardsV2Interface.RewardClaimWithProofStruct[],
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    claim(
+      _rewardOwner: PromiseOrValue<string>,
+      _recipient: PromiseOrValue<string>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _wrap: PromiseOrValue<boolean>,
+      _proofs: RewardsV2Interface.RewardClaimWithProofStruct[],
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    cleanupBlockNumber(overrides?: CallOverrides): Promise<BigNumber>;
+
+    firstClaimableRewardEpochId(overrides?: CallOverrides): Promise<number>;
+
+    getCurrentRewardEpochId(overrides?: CallOverrides): Promise<number>;
+
+    getInitialRewardEpochId(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getNextClaimableRewardEpochId(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getRewardEpochIdToExpireNext(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getRewardEpochIdsWithClaimableRewards(
+      overrides?: CallOverrides
+    ): Promise<
+      [number, number] & { _startEpochId: number; _endEpochId: number }
+    >;
+
+    getRewardEpochTotals(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+        _totalRewardsWei: BigNumber;
+        _totalInflationRewardsWei: BigNumber;
+        _initialisedRewardsWei: BigNumber;
+        _claimedRewardsWei: BigNumber;
+        _burnedRewardsWei: BigNumber;
+      }
+    >;
+
+    getStateOfRewards(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<RewardsV2Interface.RewardStateStructOutput[][]>;
+
+    getStateOfRewardsAt(
+      _rewardOwner: PromiseOrValue<string>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<RewardsV2Interface.RewardStateStructOutput[]>;
+
+    getTotals(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber] & {
+        _totalRewardsWei: BigNumber;
+        _totalInflationRewardsWei: BigNumber;
+        _totalClaimedWei: BigNumber;
+        _totalBurnedWei: BigNumber;
+      }
+    >;
+
+    getUnclaimedRewardState(
+      _beneficiary: PromiseOrValue<string>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _claimType: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<IRewardManager.UnclaimedRewardStateStructOutput>;
+
+    initialiseWeightBasedClaims(
+      _proofs: RewardsV2Interface.RewardClaimWithProofStruct[],
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    noOfInitialisedWeightBasedClaims(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  filters: {
+    "RewardClaimed(address,address,address,uint24,uint8,uint120)"(
+      beneficiary?: PromiseOrValue<string> | null,
+      rewardOwner?: PromiseOrValue<string> | null,
+      recipient?: PromiseOrValue<string> | null,
+      rewardEpochId?: null,
+      claimType?: null,
+      amount?: null
+    ): RewardClaimedEventFilter;
+    RewardClaimed(
+      beneficiary?: PromiseOrValue<string> | null,
+      rewardOwner?: PromiseOrValue<string> | null,
+      recipient?: PromiseOrValue<string> | null,
+      rewardEpochId?: null,
+      claimType?: null,
+      amount?: null
+    ): RewardClaimedEventFilter;
+
+    "RewardClaimsEnabled(uint256)"(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null
+    ): RewardClaimsEnabledEventFilter;
+    RewardClaimsEnabled(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null
+    ): RewardClaimsEnabledEventFilter;
+
+    "RewardClaimsExpired(uint256)"(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null
+    ): RewardClaimsExpiredEventFilter;
+    RewardClaimsExpired(
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null
+    ): RewardClaimsExpiredEventFilter;
+  };
+
+  estimateGas: {
+    active(overrides?: CallOverrides): Promise<BigNumber>;
+
+    autoClaim(
+      _rewardOwners: PromiseOrValue<string>[],
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _proofs: RewardsV2Interface.RewardClaimWithProofStruct[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    claim(
+      _rewardOwner: PromiseOrValue<string>,
+      _recipient: PromiseOrValue<string>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _wrap: PromiseOrValue<boolean>,
+      _proofs: RewardsV2Interface.RewardClaimWithProofStruct[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    cleanupBlockNumber(overrides?: CallOverrides): Promise<BigNumber>;
+
+    firstClaimableRewardEpochId(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentRewardEpochId(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getInitialRewardEpochId(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getNextClaimableRewardEpochId(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getRewardEpochIdToExpireNext(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getRewardEpochIdsWithClaimableRewards(
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getRewardEpochTotals(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getStateOfRewards(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getStateOfRewardsAt(
+      _rewardOwner: PromiseOrValue<string>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getTotals(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getUnclaimedRewardState(
+      _beneficiary: PromiseOrValue<string>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _claimType: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    initialiseWeightBasedClaims(
+      _proofs: RewardsV2Interface.RewardClaimWithProofStruct[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    noOfInitialisedWeightBasedClaims(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    active(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    autoClaim(
+      _rewardOwners: PromiseOrValue<string>[],
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _proofs: RewardsV2Interface.RewardClaimWithProofStruct[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    claim(
+      _rewardOwner: PromiseOrValue<string>,
+      _recipient: PromiseOrValue<string>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _wrap: PromiseOrValue<boolean>,
+      _proofs: RewardsV2Interface.RewardClaimWithProofStruct[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    cleanupBlockNumber(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    firstClaimableRewardEpochId(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getCurrentRewardEpochId(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getInitialRewardEpochId(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getNextClaimableRewardEpochId(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getRewardEpochIdToExpireNext(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getRewardEpochIdsWithClaimableRewards(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getRewardEpochTotals(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getStateOfRewards(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getStateOfRewardsAt(
+      _rewardOwner: PromiseOrValue<string>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getTotals(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getUnclaimedRewardState(
+      _beneficiary: PromiseOrValue<string>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _claimType: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    initialiseWeightBasedClaims(
+      _proofs: RewardsV2Interface.RewardClaimWithProofStruct[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    noOfInitialisedWeightBasedClaims(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/ISubmission.ts

@@ -0,0 +1,335 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export interface ISubmissionInterface extends utils.Interface {
+  functions: {
+    "getCurrentRandom()": FunctionFragment;
+    "getCurrentRandomWithQuality()": FunctionFragment;
+    "getCurrentRandomWithQualityAndTimestamp()": FunctionFragment;
+    "submit1()": FunctionFragment;
+    "submit2()": FunctionFragment;
+    "submit3()": FunctionFragment;
+    "submitAndPass(bytes)": FunctionFragment;
+    "submitSignatures()": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "getCurrentRandom"
+      | "getCurrentRandomWithQuality"
+      | "getCurrentRandomWithQualityAndTimestamp"
+      | "submit1"
+      | "submit2"
+      | "submit3"
+      | "submitAndPass"
+      | "submitSignatures"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "getCurrentRandom",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentRandomWithQuality",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentRandomWithQualityAndTimestamp",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "submit1", values?: undefined): string;
+  encodeFunctionData(functionFragment: "submit2", values?: undefined): string;
+  encodeFunctionData(functionFragment: "submit3", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "submitAndPass",
+    values: [PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "submitSignatures",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "getCurrentRandom",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentRandomWithQuality",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentRandomWithQualityAndTimestamp",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "submit1", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "submit2", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "submit3", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "submitAndPass",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "submitSignatures",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "NewVotingRoundInitiated()": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "NewVotingRoundInitiated"): EventFragment;
+}
+
+export interface NewVotingRoundInitiatedEventObject {}
+export type NewVotingRoundInitiatedEvent = TypedEvent<
+  [],
+  NewVotingRoundInitiatedEventObject
+>;
+
+export type NewVotingRoundInitiatedEventFilter =
+  TypedEventFilter<NewVotingRoundInitiatedEvent>;
+
+export interface ISubmission extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: ISubmissionInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    getCurrentRandom(
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { _randomNumber: BigNumber }>;
+
+    getCurrentRandomWithQuality(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, boolean] & {
+        _randomNumber: BigNumber;
+        _isSecureRandom: boolean;
+      }
+    >;
+
+    getCurrentRandomWithQualityAndTimestamp(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, boolean, BigNumber] & {
+        _randomNumber: BigNumber;
+        _isSecureRandom: boolean;
+        _randomTimestamp: BigNumber;
+      }
+    >;
+
+    submit1(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    submit2(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    submit3(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    submitAndPass(
+      _data: PromiseOrValue<BytesLike>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    submitSignatures(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  getCurrentRandom(overrides?: CallOverrides): Promise<BigNumber>;
+
+  getCurrentRandomWithQuality(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, boolean] & {
+      _randomNumber: BigNumber;
+      _isSecureRandom: boolean;
+    }
+  >;
+
+  getCurrentRandomWithQualityAndTimestamp(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, boolean, BigNumber] & {
+      _randomNumber: BigNumber;
+      _isSecureRandom: boolean;
+      _randomTimestamp: BigNumber;
+    }
+  >;
+
+  submit1(
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  submit2(
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  submit3(
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  submitAndPass(
+    _data: PromiseOrValue<BytesLike>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  submitSignatures(
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    getCurrentRandom(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentRandomWithQuality(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, boolean] & {
+        _randomNumber: BigNumber;
+        _isSecureRandom: boolean;
+      }
+    >;
+
+    getCurrentRandomWithQualityAndTimestamp(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, boolean, BigNumber] & {
+        _randomNumber: BigNumber;
+        _isSecureRandom: boolean;
+        _randomTimestamp: BigNumber;
+      }
+    >;
+
+    submit1(overrides?: CallOverrides): Promise<boolean>;
+
+    submit2(overrides?: CallOverrides): Promise<boolean>;
+
+    submit3(overrides?: CallOverrides): Promise<boolean>;
+
+    submitAndPass(
+      _data: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    submitSignatures(overrides?: CallOverrides): Promise<boolean>;
+  };
+
+  filters: {
+    "NewVotingRoundInitiated()"(): NewVotingRoundInitiatedEventFilter;
+    NewVotingRoundInitiated(): NewVotingRoundInitiatedEventFilter;
+  };
+
+  estimateGas: {
+    getCurrentRandom(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentRandomWithQuality(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentRandomWithQualityAndTimestamp(
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    submit1(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    submit2(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    submit3(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    submitAndPass(
+      _data: PromiseOrValue<BytesLike>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    submitSignatures(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    getCurrentRandom(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getCurrentRandomWithQuality(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getCurrentRandomWithQualityAndTimestamp(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    submit1(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    submit2(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    submit3(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    submitAndPass(
+      _data: PromiseOrValue<BytesLike>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    submitSignatures(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IVPContractEvents.ts

@@ -0,0 +1,114 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type { BaseContract, BigNumber, Signer, utils } from "ethers";
+import type { EventFragment } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export interface IVPContractEventsInterface extends utils.Interface {
+  functions: {};
+
+  events: {
+    "Delegate(address,address,uint256,uint256)": EventFragment;
+    "Revoke(address,address,uint256,uint256)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "Delegate"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "Revoke"): EventFragment;
+}
+
+export interface DelegateEventObject {
+  from: string;
+  to: string;
+  priorVotePower: BigNumber;
+  newVotePower: BigNumber;
+}
+export type DelegateEvent = TypedEvent<
+  [string, string, BigNumber, BigNumber],
+  DelegateEventObject
+>;
+
+export type DelegateEventFilter = TypedEventFilter<DelegateEvent>;
+
+export interface RevokeEventObject {
+  delegator: string;
+  delegatee: string;
+  votePower: BigNumber;
+  blockNumber: BigNumber;
+}
+export type RevokeEvent = TypedEvent<
+  [string, string, BigNumber, BigNumber],
+  RevokeEventObject
+>;
+
+export type RevokeEventFilter = TypedEventFilter<RevokeEvent>;
+
+export interface IVPContractEvents extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IVPContractEventsInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {};
+
+  callStatic: {};
+
+  filters: {
+    "Delegate(address,address,uint256,uint256)"(
+      from?: PromiseOrValue<string> | null,
+      to?: PromiseOrValue<string> | null,
+      priorVotePower?: null,
+      newVotePower?: null
+    ): DelegateEventFilter;
+    Delegate(
+      from?: PromiseOrValue<string> | null,
+      to?: PromiseOrValue<string> | null,
+      priorVotePower?: null,
+      newVotePower?: null
+    ): DelegateEventFilter;
+
+    "Revoke(address,address,uint256,uint256)"(
+      delegator?: PromiseOrValue<string> | null,
+      delegatee?: PromiseOrValue<string> | null,
+      votePower?: null,
+      blockNumber?: null
+    ): RevokeEventFilter;
+    Revoke(
+      delegator?: PromiseOrValue<string> | null,
+      delegatee?: PromiseOrValue<string> | null,
+      votePower?: null,
+      blockNumber?: null
+    ): RevokeEventFilter;
+  };
+
+  estimateGas: {};
+
+  populateTransaction: {};
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IValidatorRegistry.ts

@@ -0,0 +1,302 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export interface IValidatorRegistryInterface extends utils.Interface {
+  functions: {
+    "getDataProviderForNodeId(bytes32)": FunctionFragment;
+    "getDataProviderForPChainPublicKey(bytes32)": FunctionFragment;
+    "getDataProviderInfo(address)": FunctionFragment;
+    "registerDataProvider(string,string)": FunctionFragment;
+    "unregisterDataProvider()": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "getDataProviderForNodeId"
+      | "getDataProviderForPChainPublicKey"
+      | "getDataProviderInfo"
+      | "registerDataProvider"
+      | "unregisterDataProvider"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "getDataProviderForNodeId",
+    values: [PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getDataProviderForPChainPublicKey",
+    values: [PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getDataProviderInfo",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "registerDataProvider",
+    values: [PromiseOrValue<string>, PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "unregisterDataProvider",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "getDataProviderForNodeId",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getDataProviderForPChainPublicKey",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getDataProviderInfo",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "registerDataProvider",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "unregisterDataProvider",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "DataProviderRegistered(address,string,string)": EventFragment;
+    "DataProviderUnregistered(address)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "DataProviderRegistered"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "DataProviderUnregistered"): EventFragment;
+}
+
+export interface DataProviderRegisteredEventObject {
+  dataProvider: string;
+  nodeId: string;
+  pChainPublicKey: string;
+}
+export type DataProviderRegisteredEvent = TypedEvent<
+  [string, string, string],
+  DataProviderRegisteredEventObject
+>;
+
+export type DataProviderRegisteredEventFilter =
+  TypedEventFilter<DataProviderRegisteredEvent>;
+
+export interface DataProviderUnregisteredEventObject {
+  dataProvider: string;
+}
+export type DataProviderUnregisteredEvent = TypedEvent<
+  [string],
+  DataProviderUnregisteredEventObject
+>;
+
+export type DataProviderUnregisteredEventFilter =
+  TypedEventFilter<DataProviderUnregisteredEvent>;
+
+export interface IValidatorRegistry extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IValidatorRegistryInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    getDataProviderForNodeId(
+      _nodeId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[string] & { _dataProvider: string }>;
+
+    getDataProviderForPChainPublicKey(
+      _pChainPublicKey: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[string] & { _dataProvider: string }>;
+
+    getDataProviderInfo(
+      _dataProvider: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<
+      [string, string] & { _nodeId: string; _pChainPublicKey: string }
+    >;
+
+    registerDataProvider(
+      _nodeId: PromiseOrValue<string>,
+      _pChainPublicKey: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    unregisterDataProvider(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  getDataProviderForNodeId(
+    _nodeId: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  getDataProviderForPChainPublicKey(
+    _pChainPublicKey: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  getDataProviderInfo(
+    _dataProvider: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<[string, string] & { _nodeId: string; _pChainPublicKey: string }>;
+
+  registerDataProvider(
+    _nodeId: PromiseOrValue<string>,
+    _pChainPublicKey: PromiseOrValue<string>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  unregisterDataProvider(
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    getDataProviderForNodeId(
+      _nodeId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    getDataProviderForPChainPublicKey(
+      _pChainPublicKey: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    getDataProviderInfo(
+      _dataProvider: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<
+      [string, string] & { _nodeId: string; _pChainPublicKey: string }
+    >;
+
+    registerDataProvider(
+      _nodeId: PromiseOrValue<string>,
+      _pChainPublicKey: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    unregisterDataProvider(overrides?: CallOverrides): Promise<void>;
+  };
+
+  filters: {
+    "DataProviderRegistered(address,string,string)"(
+      dataProvider?: PromiseOrValue<string> | null,
+      nodeId?: null,
+      pChainPublicKey?: null
+    ): DataProviderRegisteredEventFilter;
+    DataProviderRegistered(
+      dataProvider?: PromiseOrValue<string> | null,
+      nodeId?: null,
+      pChainPublicKey?: null
+    ): DataProviderRegisteredEventFilter;
+
+    "DataProviderUnregistered(address)"(
+      dataProvider?: PromiseOrValue<string> | null
+    ): DataProviderUnregisteredEventFilter;
+    DataProviderUnregistered(
+      dataProvider?: PromiseOrValue<string> | null
+    ): DataProviderUnregisteredEventFilter;
+  };
+
+  estimateGas: {
+    getDataProviderForNodeId(
+      _nodeId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getDataProviderForPChainPublicKey(
+      _pChainPublicKey: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getDataProviderInfo(
+      _dataProvider: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    registerDataProvider(
+      _nodeId: PromiseOrValue<string>,
+      _pChainPublicKey: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    unregisterDataProvider(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    getDataProviderForNodeId(
+      _nodeId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getDataProviderForPChainPublicKey(
+      _pChainPublicKey: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getDataProviderInfo(
+      _dataProvider: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    registerDataProvider(
+      _nodeId: PromiseOrValue<string>,
+      _pChainPublicKey: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    unregisterDataProvider(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IVoterRegistry.ts

@@ -0,0 +1,433 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export declare namespace IVoterRegistry {
+  export type SignatureStruct = {
+    v: PromiseOrValue<BigNumberish>;
+    r: PromiseOrValue<BytesLike>;
+    s: PromiseOrValue<BytesLike>;
+  };
+
+  export type SignatureStructOutput = [number, string, string] & {
+    v: number;
+    r: string;
+    s: string;
+  };
+}
+
+export interface IVoterRegistryInterface extends utils.Interface {
+  functions: {
+    "chilledUntilRewardEpochId(bytes20)": FunctionFragment;
+    "getNumberOfRegisteredVoters(uint256)": FunctionFragment;
+    "getRegisteredVoters(uint256)": FunctionFragment;
+    "isVoterRegistered(address,uint256)": FunctionFragment;
+    "maxVoters()": FunctionFragment;
+    "newSigningPolicyInitializationStartBlockNumber(uint256)": FunctionFragment;
+    "publicKeyRequired()": FunctionFragment;
+    "registerVoter(address,(uint8,bytes32,bytes32))": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "chilledUntilRewardEpochId"
+      | "getNumberOfRegisteredVoters"
+      | "getRegisteredVoters"
+      | "isVoterRegistered"
+      | "maxVoters"
+      | "newSigningPolicyInitializationStartBlockNumber"
+      | "publicKeyRequired"
+      | "registerVoter"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "chilledUntilRewardEpochId",
+    values: [PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getNumberOfRegisteredVoters",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRegisteredVoters",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isVoterRegistered",
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(functionFragment: "maxVoters", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "newSigningPolicyInitializationStartBlockNumber",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "publicKeyRequired",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "registerVoter",
+    values: [PromiseOrValue<string>, IVoterRegistry.SignatureStruct]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "chilledUntilRewardEpochId",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getNumberOfRegisteredVoters",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRegisteredVoters",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "isVoterRegistered",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "maxVoters", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "newSigningPolicyInitializationStartBlockNumber",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "publicKeyRequired",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "registerVoter",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "BeneficiaryChilled(bytes20,uint256)": EventFragment;
+    "VoterRegistered(address,uint24,address,address,address,bytes32,bytes32,uint256)": EventFragment;
+    "VoterRemoved(address,uint256)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "BeneficiaryChilled"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "VoterRegistered"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "VoterRemoved"): EventFragment;
+}
+
+export interface BeneficiaryChilledEventObject {
+  beneficiary: string;
+  untilRewardEpochId: BigNumber;
+}
+export type BeneficiaryChilledEvent = TypedEvent<
+  [string, BigNumber],
+  BeneficiaryChilledEventObject
+>;
+
+export type BeneficiaryChilledEventFilter =
+  TypedEventFilter<BeneficiaryChilledEvent>;
+
+export interface VoterRegisteredEventObject {
+  voter: string;
+  rewardEpochId: number;
+  signingPolicyAddress: string;
+  submitAddress: string;
+  submitSignaturesAddress: string;
+  publicKeyPart1: string;
+  publicKeyPart2: string;
+  registrationWeight: BigNumber;
+}
+export type VoterRegisteredEvent = TypedEvent<
+  [string, number, string, string, string, string, string, BigNumber],
+  VoterRegisteredEventObject
+>;
+
+export type VoterRegisteredEventFilter = TypedEventFilter<VoterRegisteredEvent>;
+
+export interface VoterRemovedEventObject {
+  voter: string;
+  rewardEpochId: BigNumber;
+}
+export type VoterRemovedEvent = TypedEvent<
+  [string, BigNumber],
+  VoterRemovedEventObject
+>;
+
+export type VoterRemovedEventFilter = TypedEventFilter<VoterRemovedEvent>;
+
+export interface IVoterRegistry extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IVoterRegistryInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    chilledUntilRewardEpochId(
+      _beneficiary: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { _rewardEpochId: BigNumber }>;
+
+    getNumberOfRegisteredVoters(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    getRegisteredVoters(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[string[]]>;
+
+    isVoterRegistered(
+      _voter: PromiseOrValue<string>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[boolean]>;
+
+    maxVoters(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    newSigningPolicyInitializationStartBlockNumber(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    publicKeyRequired(overrides?: CallOverrides): Promise<[boolean]>;
+
+    registerVoter(
+      _voter: PromiseOrValue<string>,
+      _signature: IVoterRegistry.SignatureStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  chilledUntilRewardEpochId(
+    _beneficiary: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  getNumberOfRegisteredVoters(
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  getRegisteredVoters(
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string[]>;
+
+  isVoterRegistered(
+    _voter: PromiseOrValue<string>,
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<boolean>;
+
+  maxVoters(overrides?: CallOverrides): Promise<BigNumber>;
+
+  newSigningPolicyInitializationStartBlockNumber(
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  publicKeyRequired(overrides?: CallOverrides): Promise<boolean>;
+
+  registerVoter(
+    _voter: PromiseOrValue<string>,
+    _signature: IVoterRegistry.SignatureStruct,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    chilledUntilRewardEpochId(
+      _beneficiary: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getNumberOfRegisteredVoters(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getRegisteredVoters(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<string[]>;
+
+    isVoterRegistered(
+      _voter: PromiseOrValue<string>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    maxVoters(overrides?: CallOverrides): Promise<BigNumber>;
+
+    newSigningPolicyInitializationStartBlockNumber(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    publicKeyRequired(overrides?: CallOverrides): Promise<boolean>;
+
+    registerVoter(
+      _voter: PromiseOrValue<string>,
+      _signature: IVoterRegistry.SignatureStruct,
+      overrides?: CallOverrides
+    ): Promise<void>;
+  };
+
+  filters: {
+    "BeneficiaryChilled(bytes20,uint256)"(
+      beneficiary?: PromiseOrValue<BytesLike> | null,
+      untilRewardEpochId?: null
+    ): BeneficiaryChilledEventFilter;
+    BeneficiaryChilled(
+      beneficiary?: PromiseOrValue<BytesLike> | null,
+      untilRewardEpochId?: null
+    ): BeneficiaryChilledEventFilter;
+
+    "VoterRegistered(address,uint24,address,address,address,bytes32,bytes32,uint256)"(
+      voter?: PromiseOrValue<string> | null,
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      signingPolicyAddress?: PromiseOrValue<string> | null,
+      submitAddress?: null,
+      submitSignaturesAddress?: null,
+      publicKeyPart1?: null,
+      publicKeyPart2?: null,
+      registrationWeight?: null
+    ): VoterRegisteredEventFilter;
+    VoterRegistered(
+      voter?: PromiseOrValue<string> | null,
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null,
+      signingPolicyAddress?: PromiseOrValue<string> | null,
+      submitAddress?: null,
+      submitSignaturesAddress?: null,
+      publicKeyPart1?: null,
+      publicKeyPart2?: null,
+      registrationWeight?: null
+    ): VoterRegisteredEventFilter;
+
+    "VoterRemoved(address,uint256)"(
+      voter?: PromiseOrValue<string> | null,
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null
+    ): VoterRemovedEventFilter;
+    VoterRemoved(
+      voter?: PromiseOrValue<string> | null,
+      rewardEpochId?: PromiseOrValue<BigNumberish> | null
+    ): VoterRemovedEventFilter;
+  };
+
+  estimateGas: {
+    chilledUntilRewardEpochId(
+      _beneficiary: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getNumberOfRegisteredVoters(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getRegisteredVoters(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    isVoterRegistered(
+      _voter: PromiseOrValue<string>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    maxVoters(overrides?: CallOverrides): Promise<BigNumber>;
+
+    newSigningPolicyInitializationStartBlockNumber(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    publicKeyRequired(overrides?: CallOverrides): Promise<BigNumber>;
+
+    registerVoter(
+      _voter: PromiseOrValue<string>,
+      _signature: IVoterRegistry.SignatureStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    chilledUntilRewardEpochId(
+      _beneficiary: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getNumberOfRegisteredVoters(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getRegisteredVoters(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    isVoterRegistered(
+      _voter: PromiseOrValue<string>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    maxVoters(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    newSigningPolicyInitializationStartBlockNumber(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    publicKeyRequired(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    registerVoter(
+      _voter: PromiseOrValue<string>,
+      _signature: IVoterRegistry.SignatureStruct,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IVoterWhitelister.ts

@@ -0,0 +1,390 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export interface IVoterWhitelisterInterface extends utils.Interface {
+  functions: {
+    "chilledUntilRewardEpoch(address)": FunctionFragment;
+    "defaultMaxVotersForFtso()": FunctionFragment;
+    "getFtsoWhitelistedPriceProviders(uint256)": FunctionFragment;
+    "getFtsoWhitelistedPriceProvidersBySymbol(string)": FunctionFragment;
+    "maxVotersForFtso(uint256)": FunctionFragment;
+    "requestFullVoterWhitelisting(address)": FunctionFragment;
+    "requestWhitelistingVoter(address,uint256)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "chilledUntilRewardEpoch"
+      | "defaultMaxVotersForFtso"
+      | "getFtsoWhitelistedPriceProviders"
+      | "getFtsoWhitelistedPriceProvidersBySymbol"
+      | "maxVotersForFtso"
+      | "requestFullVoterWhitelisting"
+      | "requestWhitelistingVoter"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "chilledUntilRewardEpoch",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "defaultMaxVotersForFtso",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFtsoWhitelistedPriceProviders",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFtsoWhitelistedPriceProvidersBySymbol",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "maxVotersForFtso",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "requestFullVoterWhitelisting",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "requestWhitelistingVoter",
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "chilledUntilRewardEpoch",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "defaultMaxVotersForFtso",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getFtsoWhitelistedPriceProviders",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getFtsoWhitelistedPriceProvidersBySymbol",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "maxVotersForFtso",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "requestFullVoterWhitelisting",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "requestWhitelistingVoter",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "VoterChilled(address,uint256)": EventFragment;
+    "VoterRemovedFromWhitelist(address,uint256)": EventFragment;
+    "VoterWhitelisted(address,uint256)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "VoterChilled"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "VoterRemovedFromWhitelist"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "VoterWhitelisted"): EventFragment;
+}
+
+export interface VoterChilledEventObject {
+  voter: string;
+  untilRewardEpoch: BigNumber;
+}
+export type VoterChilledEvent = TypedEvent<
+  [string, BigNumber],
+  VoterChilledEventObject
+>;
+
+export type VoterChilledEventFilter = TypedEventFilter<VoterChilledEvent>;
+
+export interface VoterRemovedFromWhitelistEventObject {
+  voter: string;
+  ftsoIndex: BigNumber;
+}
+export type VoterRemovedFromWhitelistEvent = TypedEvent<
+  [string, BigNumber],
+  VoterRemovedFromWhitelistEventObject
+>;
+
+export type VoterRemovedFromWhitelistEventFilter =
+  TypedEventFilter<VoterRemovedFromWhitelistEvent>;
+
+export interface VoterWhitelistedEventObject {
+  voter: string;
+  ftsoIndex: BigNumber;
+}
+export type VoterWhitelistedEvent = TypedEvent<
+  [string, BigNumber],
+  VoterWhitelistedEventObject
+>;
+
+export type VoterWhitelistedEventFilter =
+  TypedEventFilter<VoterWhitelistedEvent>;
+
+export interface IVoterWhitelister extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IVoterWhitelisterInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    chilledUntilRewardEpoch(
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    defaultMaxVotersForFtso(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    getFtsoWhitelistedPriceProviders(
+      _ftsoIndex: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[string[]]>;
+
+    getFtsoWhitelistedPriceProvidersBySymbol(
+      _symbol: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[string[]]>;
+
+    maxVotersForFtso(
+      _ftsoIndex: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    requestFullVoterWhitelisting(
+      _voter: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    requestWhitelistingVoter(
+      _voter: PromiseOrValue<string>,
+      _ftsoIndex: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  chilledUntilRewardEpoch(
+    _voter: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  defaultMaxVotersForFtso(overrides?: CallOverrides): Promise<BigNumber>;
+
+  getFtsoWhitelistedPriceProviders(
+    _ftsoIndex: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string[]>;
+
+  getFtsoWhitelistedPriceProvidersBySymbol(
+    _symbol: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<string[]>;
+
+  maxVotersForFtso(
+    _ftsoIndex: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  requestFullVoterWhitelisting(
+    _voter: PromiseOrValue<string>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  requestWhitelistingVoter(
+    _voter: PromiseOrValue<string>,
+    _ftsoIndex: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    chilledUntilRewardEpoch(
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    defaultMaxVotersForFtso(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getFtsoWhitelistedPriceProviders(
+      _ftsoIndex: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<string[]>;
+
+    getFtsoWhitelistedPriceProvidersBySymbol(
+      _symbol: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<string[]>;
+
+    maxVotersForFtso(
+      _ftsoIndex: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    requestFullVoterWhitelisting(
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber[], boolean[]] & {
+        _supportedIndices: BigNumber[];
+        _success: boolean[];
+      }
+    >;
+
+    requestWhitelistingVoter(
+      _voter: PromiseOrValue<string>,
+      _ftsoIndex: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+  };
+
+  filters: {
+    "VoterChilled(address,uint256)"(
+      voter?: null,
+      untilRewardEpoch?: null
+    ): VoterChilledEventFilter;
+    VoterChilled(
+      voter?: null,
+      untilRewardEpoch?: null
+    ): VoterChilledEventFilter;
+
+    "VoterRemovedFromWhitelist(address,uint256)"(
+      voter?: null,
+      ftsoIndex?: null
+    ): VoterRemovedFromWhitelistEventFilter;
+    VoterRemovedFromWhitelist(
+      voter?: null,
+      ftsoIndex?: null
+    ): VoterRemovedFromWhitelistEventFilter;
+
+    "VoterWhitelisted(address,uint256)"(
+      voter?: null,
+      ftsoIndex?: null
+    ): VoterWhitelistedEventFilter;
+    VoterWhitelisted(
+      voter?: null,
+      ftsoIndex?: null
+    ): VoterWhitelistedEventFilter;
+  };
+
+  estimateGas: {
+    chilledUntilRewardEpoch(
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    defaultMaxVotersForFtso(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getFtsoWhitelistedPriceProviders(
+      _ftsoIndex: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getFtsoWhitelistedPriceProvidersBySymbol(
+      _symbol: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    maxVotersForFtso(
+      _ftsoIndex: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    requestFullVoterWhitelisting(
+      _voter: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    requestWhitelistingVoter(
+      _voter: PromiseOrValue<string>,
+      _ftsoIndex: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    chilledUntilRewardEpoch(
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    defaultMaxVotersForFtso(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getFtsoWhitelistedPriceProviders(
+      _ftsoIndex: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getFtsoWhitelistedPriceProvidersBySymbol(
+      _symbol: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    maxVotersForFtso(
+      _ftsoIndex: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    requestFullVoterWhitelisting(
+      _voter: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    requestWhitelistingVoter(
+      _voter: PromiseOrValue<string>,
+      _ftsoIndex: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/IWNatDelegationFee.ts

@@ -0,0 +1,313 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export interface IWNatDelegationFeeInterface extends utils.Interface {
+  functions: {
+    "defaultFeePercentageBIPS()": FunctionFragment;
+    "feePercentageUpdateOffset()": FunctionFragment;
+    "getVoterCurrentFeePercentage(address)": FunctionFragment;
+    "getVoterFeePercentage(address,uint256)": FunctionFragment;
+    "getVoterScheduledFeePercentageChanges(address)": FunctionFragment;
+    "setVoterFeePercentage(uint16)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "defaultFeePercentageBIPS"
+      | "feePercentageUpdateOffset"
+      | "getVoterCurrentFeePercentage"
+      | "getVoterFeePercentage"
+      | "getVoterScheduledFeePercentageChanges"
+      | "setVoterFeePercentage"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "defaultFeePercentageBIPS",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "feePercentageUpdateOffset",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getVoterCurrentFeePercentage",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getVoterFeePercentage",
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getVoterScheduledFeePercentageChanges",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setVoterFeePercentage",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "defaultFeePercentageBIPS",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "feePercentageUpdateOffset",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getVoterCurrentFeePercentage",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getVoterFeePercentage",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getVoterScheduledFeePercentageChanges",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "setVoterFeePercentage",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "FeePercentageChanged(address,uint16,uint24)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "FeePercentageChanged"): EventFragment;
+}
+
+export interface FeePercentageChangedEventObject {
+  voter: string;
+  value: number;
+  validFromEpochId: number;
+}
+export type FeePercentageChangedEvent = TypedEvent<
+  [string, number, number],
+  FeePercentageChangedEventObject
+>;
+
+export type FeePercentageChangedEventFilter =
+  TypedEventFilter<FeePercentageChangedEvent>;
+
+export interface IWNatDelegationFee extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IWNatDelegationFeeInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    defaultFeePercentageBIPS(overrides?: CallOverrides): Promise<[number]>;
+
+    feePercentageUpdateOffset(overrides?: CallOverrides): Promise<[number]>;
+
+    getVoterCurrentFeePercentage(
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[number]>;
+
+    getVoterFeePercentage(
+      _voter: PromiseOrValue<string>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[number]>;
+
+    getVoterScheduledFeePercentageChanges(
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber[], BigNumber[], boolean[]] & {
+        _feePercentageBIPS: BigNumber[];
+        _validFromEpochId: BigNumber[];
+        _fixed: boolean[];
+      }
+    >;
+
+    setVoterFeePercentage(
+      _feePercentageBIPS: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  defaultFeePercentageBIPS(overrides?: CallOverrides): Promise<number>;
+
+  feePercentageUpdateOffset(overrides?: CallOverrides): Promise<number>;
+
+  getVoterCurrentFeePercentage(
+    _voter: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<number>;
+
+  getVoterFeePercentage(
+    _voter: PromiseOrValue<string>,
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<number>;
+
+  getVoterScheduledFeePercentageChanges(
+    _voter: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber[], BigNumber[], boolean[]] & {
+      _feePercentageBIPS: BigNumber[];
+      _validFromEpochId: BigNumber[];
+      _fixed: boolean[];
+    }
+  >;
+
+  setVoterFeePercentage(
+    _feePercentageBIPS: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    defaultFeePercentageBIPS(overrides?: CallOverrides): Promise<number>;
+
+    feePercentageUpdateOffset(overrides?: CallOverrides): Promise<number>;
+
+    getVoterCurrentFeePercentage(
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<number>;
+
+    getVoterFeePercentage(
+      _voter: PromiseOrValue<string>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<number>;
+
+    getVoterScheduledFeePercentageChanges(
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber[], BigNumber[], boolean[]] & {
+        _feePercentageBIPS: BigNumber[];
+        _validFromEpochId: BigNumber[];
+        _fixed: boolean[];
+      }
+    >;
+
+    setVoterFeePercentage(
+      _feePercentageBIPS: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  filters: {
+    "FeePercentageChanged(address,uint16,uint24)"(
+      voter?: PromiseOrValue<string> | null,
+      value?: null,
+      validFromEpochId?: null
+    ): FeePercentageChangedEventFilter;
+    FeePercentageChanged(
+      voter?: PromiseOrValue<string> | null,
+      value?: null,
+      validFromEpochId?: null
+    ): FeePercentageChangedEventFilter;
+  };
+
+  estimateGas: {
+    defaultFeePercentageBIPS(overrides?: CallOverrides): Promise<BigNumber>;
+
+    feePercentageUpdateOffset(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getVoterCurrentFeePercentage(
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getVoterFeePercentage(
+      _voter: PromiseOrValue<string>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getVoterScheduledFeePercentageChanges(
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    setVoterFeePercentage(
+      _feePercentageBIPS: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    defaultFeePercentageBIPS(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    feePercentageUpdateOffset(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getVoterCurrentFeePercentage(
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getVoterFeePercentage(
+      _voter: PromiseOrValue<string>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getVoterScheduledFeePercentageChanges(
+      _voter: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    setVoterFeePercentage(
+      _feePercentageBIPS: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/ProtocolsV2Interface.ts

@@ -0,0 +1,274 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export interface ProtocolsV2InterfaceInterface extends utils.Interface {
+  functions: {
+    "firstRewardEpochStartTs()": FunctionFragment;
+    "firstVotingRoundStartTs()": FunctionFragment;
+    "getCurrentRewardEpochId()": FunctionFragment;
+    "getCurrentVotingEpochId()": FunctionFragment;
+    "getStartVotingRoundId(uint256)": FunctionFragment;
+    "getVotePowerBlock(uint256)": FunctionFragment;
+    "rewardEpochDurationSeconds()": FunctionFragment;
+    "votingEpochDurationSeconds()": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "firstRewardEpochStartTs"
+      | "firstVotingRoundStartTs"
+      | "getCurrentRewardEpochId"
+      | "getCurrentVotingEpochId"
+      | "getStartVotingRoundId"
+      | "getVotePowerBlock"
+      | "rewardEpochDurationSeconds"
+      | "votingEpochDurationSeconds"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "firstRewardEpochStartTs",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "firstVotingRoundStartTs",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentRewardEpochId",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCurrentVotingEpochId",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getStartVotingRoundId",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getVotePowerBlock",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "rewardEpochDurationSeconds",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "votingEpochDurationSeconds",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "firstRewardEpochStartTs",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "firstVotingRoundStartTs",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentRewardEpochId",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getCurrentVotingEpochId",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getStartVotingRoundId",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getVotePowerBlock",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "rewardEpochDurationSeconds",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "votingEpochDurationSeconds",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface ProtocolsV2Interface extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: ProtocolsV2InterfaceInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    firstRewardEpochStartTs(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    firstVotingRoundStartTs(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    getCurrentRewardEpochId(overrides?: CallOverrides): Promise<[number]>;
+
+    getCurrentVotingEpochId(overrides?: CallOverrides): Promise<[number]>;
+
+    getStartVotingRoundId(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[number]>;
+
+    getVotePowerBlock(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { _votePowerBlock: BigNumber }>;
+
+    rewardEpochDurationSeconds(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    votingEpochDurationSeconds(overrides?: CallOverrides): Promise<[BigNumber]>;
+  };
+
+  firstRewardEpochStartTs(overrides?: CallOverrides): Promise<BigNumber>;
+
+  firstVotingRoundStartTs(overrides?: CallOverrides): Promise<BigNumber>;
+
+  getCurrentRewardEpochId(overrides?: CallOverrides): Promise<number>;
+
+  getCurrentVotingEpochId(overrides?: CallOverrides): Promise<number>;
+
+  getStartVotingRoundId(
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<number>;
+
+  getVotePowerBlock(
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  rewardEpochDurationSeconds(overrides?: CallOverrides): Promise<BigNumber>;
+
+  votingEpochDurationSeconds(overrides?: CallOverrides): Promise<BigNumber>;
+
+  callStatic: {
+    firstRewardEpochStartTs(overrides?: CallOverrides): Promise<BigNumber>;
+
+    firstVotingRoundStartTs(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentRewardEpochId(overrides?: CallOverrides): Promise<number>;
+
+    getCurrentVotingEpochId(overrides?: CallOverrides): Promise<number>;
+
+    getStartVotingRoundId(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<number>;
+
+    getVotePowerBlock(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    rewardEpochDurationSeconds(overrides?: CallOverrides): Promise<BigNumber>;
+
+    votingEpochDurationSeconds(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    firstRewardEpochStartTs(overrides?: CallOverrides): Promise<BigNumber>;
+
+    firstVotingRoundStartTs(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentRewardEpochId(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getCurrentVotingEpochId(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getStartVotingRoundId(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getVotePowerBlock(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    rewardEpochDurationSeconds(overrides?: CallOverrides): Promise<BigNumber>;
+
+    votingEpochDurationSeconds(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    firstRewardEpochStartTs(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    firstVotingRoundStartTs(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getCurrentRewardEpochId(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getCurrentVotingEpochId(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getStartVotingRoundId(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getVotePowerBlock(
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    rewardEpochDurationSeconds(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    votingEpochDurationSeconds(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/RandomNumberV2Interface.ts

@@ -0,0 +1,167 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export interface RandomNumberV2InterfaceInterface extends utils.Interface {
+  functions: {
+    "getRandomNumber()": FunctionFragment;
+    "getRandomNumberHistorical(uint256)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic: "getRandomNumber" | "getRandomNumberHistorical"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "getRandomNumber",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRandomNumberHistorical",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "getRandomNumber",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRandomNumberHistorical",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface RandomNumberV2Interface extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: RandomNumberV2InterfaceInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    getRandomNumber(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, boolean, BigNumber] & {
+        _randomNumber: BigNumber;
+        _isSecureRandom: boolean;
+        _randomTimestamp: BigNumber;
+      }
+    >;
+
+    getRandomNumberHistorical(
+      _votingRoundId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, boolean, BigNumber] & {
+        _randomNumber: BigNumber;
+        _isSecureRandom: boolean;
+        _randomTimestamp: BigNumber;
+      }
+    >;
+  };
+
+  getRandomNumber(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, boolean, BigNumber] & {
+      _randomNumber: BigNumber;
+      _isSecureRandom: boolean;
+      _randomTimestamp: BigNumber;
+    }
+  >;
+
+  getRandomNumberHistorical(
+    _votingRoundId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, boolean, BigNumber] & {
+      _randomNumber: BigNumber;
+      _isSecureRandom: boolean;
+      _randomTimestamp: BigNumber;
+    }
+  >;
+
+  callStatic: {
+    getRandomNumber(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, boolean, BigNumber] & {
+        _randomNumber: BigNumber;
+        _isSecureRandom: boolean;
+        _randomTimestamp: BigNumber;
+      }
+    >;
+
+    getRandomNumberHistorical(
+      _votingRoundId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, boolean, BigNumber] & {
+        _randomNumber: BigNumber;
+        _isSecureRandom: boolean;
+        _randomTimestamp: BigNumber;
+      }
+    >;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    getRandomNumber(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getRandomNumberHistorical(
+      _votingRoundId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    getRandomNumber(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getRandomNumberHistorical(
+      _votingRoundId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/RewardsV2Interface.ts

@@ -0,0 +1,305 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export declare namespace RewardsV2Interface {
+  export type RewardClaimStruct = {
+    rewardEpochId: PromiseOrValue<BigNumberish>;
+    beneficiary: PromiseOrValue<BytesLike>;
+    amount: PromiseOrValue<BigNumberish>;
+    claimType: PromiseOrValue<BigNumberish>;
+  };
+
+  export type RewardClaimStructOutput = [number, string, BigNumber, number] & {
+    rewardEpochId: number;
+    beneficiary: string;
+    amount: BigNumber;
+    claimType: number;
+  };
+
+  export type RewardClaimWithProofStruct = {
+    merkleProof: PromiseOrValue<BytesLike>[];
+    body: RewardsV2Interface.RewardClaimStruct;
+  };
+
+  export type RewardClaimWithProofStructOutput = [
+    string[],
+    RewardsV2Interface.RewardClaimStructOutput
+  ] & {
+    merkleProof: string[];
+    body: RewardsV2Interface.RewardClaimStructOutput;
+  };
+
+  export type RewardStateStruct = {
+    rewardEpochId: PromiseOrValue<BigNumberish>;
+    beneficiary: PromiseOrValue<BytesLike>;
+    amount: PromiseOrValue<BigNumberish>;
+    claimType: PromiseOrValue<BigNumberish>;
+    initialised: PromiseOrValue<boolean>;
+  };
+
+  export type RewardStateStructOutput = [
+    number,
+    string,
+    BigNumber,
+    number,
+    boolean
+  ] & {
+    rewardEpochId: number;
+    beneficiary: string;
+    amount: BigNumber;
+    claimType: number;
+    initialised: boolean;
+  };
+}
+
+export interface RewardsV2InterfaceInterface extends utils.Interface {
+  functions: {
+    "active()": FunctionFragment;
+    "claim(address,address,uint24,bool,(bytes32[],(uint24,bytes20,uint120,uint8))[])": FunctionFragment;
+    "getNextClaimableRewardEpochId(address)": FunctionFragment;
+    "getRewardEpochIdsWithClaimableRewards()": FunctionFragment;
+    "getStateOfRewards(address)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "active"
+      | "claim"
+      | "getNextClaimableRewardEpochId"
+      | "getRewardEpochIdsWithClaimableRewards"
+      | "getStateOfRewards"
+  ): FunctionFragment;
+
+  encodeFunctionData(functionFragment: "active", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "claim",
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<boolean>,
+      RewardsV2Interface.RewardClaimWithProofStruct[]
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getNextClaimableRewardEpochId",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRewardEpochIdsWithClaimableRewards",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getStateOfRewards",
+    values: [PromiseOrValue<string>]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "active", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "claim", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getNextClaimableRewardEpochId",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRewardEpochIdsWithClaimableRewards",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getStateOfRewards",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface RewardsV2Interface extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: RewardsV2InterfaceInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    active(overrides?: CallOverrides): Promise<[boolean]>;
+
+    claim(
+      _rewardOwner: PromiseOrValue<string>,
+      _recipient: PromiseOrValue<string>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _wrap: PromiseOrValue<boolean>,
+      _proofs: RewardsV2Interface.RewardClaimWithProofStruct[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    getNextClaimableRewardEpochId(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    getRewardEpochIdsWithClaimableRewards(
+      overrides?: CallOverrides
+    ): Promise<
+      [number, number] & { _startEpochId: number; _endEpochId: number }
+    >;
+
+    getStateOfRewards(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<
+      [RewardsV2Interface.RewardStateStructOutput[][]] & {
+        _rewardStates: RewardsV2Interface.RewardStateStructOutput[][];
+      }
+    >;
+  };
+
+  active(overrides?: CallOverrides): Promise<boolean>;
+
+  claim(
+    _rewardOwner: PromiseOrValue<string>,
+    _recipient: PromiseOrValue<string>,
+    _rewardEpochId: PromiseOrValue<BigNumberish>,
+    _wrap: PromiseOrValue<boolean>,
+    _proofs: RewardsV2Interface.RewardClaimWithProofStruct[],
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  getNextClaimableRewardEpochId(
+    _rewardOwner: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  getRewardEpochIdsWithClaimableRewards(
+    overrides?: CallOverrides
+  ): Promise<[number, number] & { _startEpochId: number; _endEpochId: number }>;
+
+  getStateOfRewards(
+    _rewardOwner: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<RewardsV2Interface.RewardStateStructOutput[][]>;
+
+  callStatic: {
+    active(overrides?: CallOverrides): Promise<boolean>;
+
+    claim(
+      _rewardOwner: PromiseOrValue<string>,
+      _recipient: PromiseOrValue<string>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _wrap: PromiseOrValue<boolean>,
+      _proofs: RewardsV2Interface.RewardClaimWithProofStruct[],
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getNextClaimableRewardEpochId(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getRewardEpochIdsWithClaimableRewards(
+      overrides?: CallOverrides
+    ): Promise<
+      [number, number] & { _startEpochId: number; _endEpochId: number }
+    >;
+
+    getStateOfRewards(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<RewardsV2Interface.RewardStateStructOutput[][]>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    active(overrides?: CallOverrides): Promise<BigNumber>;
+
+    claim(
+      _rewardOwner: PromiseOrValue<string>,
+      _recipient: PromiseOrValue<string>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _wrap: PromiseOrValue<boolean>,
+      _proofs: RewardsV2Interface.RewardClaimWithProofStruct[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    getNextClaimableRewardEpochId(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getRewardEpochIdsWithClaimableRewards(
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getStateOfRewards(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    active(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    claim(
+      _rewardOwner: PromiseOrValue<string>,
+      _recipient: PromiseOrValue<string>,
+      _rewardEpochId: PromiseOrValue<BigNumberish>,
+      _wrap: PromiseOrValue<boolean>,
+      _proofs: RewardsV2Interface.RewardClaimWithProofStruct[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    getNextClaimableRewardEpochId(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getRewardEpochIdsWithClaimableRewards(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getStateOfRewards(
+      _rewardOwner: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/TestFtsoV2Interface.ts

@@ -0,0 +1,584 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+
+export declare namespace TestFtsoV2Interface {
+  export type FeedDataStruct = {
+    votingRoundId: PromiseOrValue<BigNumberish>;
+    id: PromiseOrValue<BytesLike>;
+    value: PromiseOrValue<BigNumberish>;
+    turnoutBIPS: PromiseOrValue<BigNumberish>;
+    decimals: PromiseOrValue<BigNumberish>;
+  };
+
+  export type FeedDataStructOutput = [
+    number,
+    string,
+    number,
+    number,
+    number
+  ] & {
+    votingRoundId: number;
+    id: string;
+    value: number;
+    turnoutBIPS: number;
+    decimals: number;
+  };
+
+  export type FeedDataWithProofStruct = {
+    proof: PromiseOrValue<BytesLike>[];
+    body: TestFtsoV2Interface.FeedDataStruct;
+  };
+
+  export type FeedDataWithProofStructOutput = [
+    string[],
+    TestFtsoV2Interface.FeedDataStructOutput
+  ] & { proof: string[]; body: TestFtsoV2Interface.FeedDataStructOutput };
+}
+
+export interface TestFtsoV2InterfaceInterface extends utils.Interface {
+  functions: {
+    "getFeedById(bytes21)": FunctionFragment;
+    "getFeedByIdInWei(bytes21)": FunctionFragment;
+    "getFeedByIndex(uint256)": FunctionFragment;
+    "getFeedByIndexInWei(uint256)": FunctionFragment;
+    "getFeedId(uint256)": FunctionFragment;
+    "getFeedIndex(bytes21)": FunctionFragment;
+    "getFeedsById(bytes21[])": FunctionFragment;
+    "getFeedsByIdInWei(bytes21[])": FunctionFragment;
+    "getFeedsByIndex(uint256[])": FunctionFragment;
+    "getFeedsByIndexInWei(uint256[])": FunctionFragment;
+    "verifyFeedData((bytes32[],(uint32,bytes21,int32,uint16,int8)))": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "getFeedById"
+      | "getFeedByIdInWei"
+      | "getFeedByIndex"
+      | "getFeedByIndexInWei"
+      | "getFeedId"
+      | "getFeedIndex"
+      | "getFeedsById"
+      | "getFeedsByIdInWei"
+      | "getFeedsByIndex"
+      | "getFeedsByIndexInWei"
+      | "verifyFeedData"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "getFeedById",
+    values: [PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFeedByIdInWei",
+    values: [PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFeedByIndex",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFeedByIndexInWei",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFeedId",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFeedIndex",
+    values: [PromiseOrValue<BytesLike>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFeedsById",
+    values: [PromiseOrValue<BytesLike>[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFeedsByIdInWei",
+    values: [PromiseOrValue<BytesLike>[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFeedsByIndex",
+    values: [PromiseOrValue<BigNumberish>[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFeedsByIndexInWei",
+    values: [PromiseOrValue<BigNumberish>[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "verifyFeedData",
+    values: [TestFtsoV2Interface.FeedDataWithProofStruct]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "getFeedById",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getFeedByIdInWei",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getFeedByIndex",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getFeedByIndexInWei",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getFeedId", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getFeedIndex",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getFeedsById",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getFeedsByIdInWei",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getFeedsByIndex",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getFeedsByIndexInWei",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "verifyFeedData",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface TestFtsoV2Interface extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: TestFtsoV2InterfaceInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    getFeedById(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, number, BigNumber] & {
+        _value: BigNumber;
+        _decimals: number;
+        _timestamp: BigNumber;
+      }
+    >;
+
+    getFeedByIdInWei(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { _value: BigNumber; _timestamp: BigNumber }
+    >;
+
+    getFeedByIndex(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, number, BigNumber] & {
+        _value: BigNumber;
+        _decimals: number;
+        _timestamp: BigNumber;
+      }
+    >;
+
+    getFeedByIndexInWei(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { _value: BigNumber; _timestamp: BigNumber }
+    >;
+
+    getFeedId(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[string] & { _feedId: string }>;
+
+    getFeedIndex(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { _index: BigNumber }>;
+
+    getFeedsById(
+      _feedIds: PromiseOrValue<BytesLike>[],
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber[], number[], BigNumber] & {
+        _values: BigNumber[];
+        _decimals: number[];
+        _timestamp: BigNumber;
+      }
+    >;
+
+    getFeedsByIdInWei(
+      _feedIds: PromiseOrValue<BytesLike>[],
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber[], BigNumber] & { _values: BigNumber[]; _timestamp: BigNumber }
+    >;
+
+    getFeedsByIndex(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber[], number[], BigNumber] & {
+        _values: BigNumber[];
+        _decimals: number[];
+        _timestamp: BigNumber;
+      }
+    >;
+
+    getFeedsByIndexInWei(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber[], BigNumber] & { _values: BigNumber[]; _timestamp: BigNumber }
+    >;
+
+    verifyFeedData(
+      _feedData: TestFtsoV2Interface.FeedDataWithProofStruct,
+      overrides?: CallOverrides
+    ): Promise<[boolean]>;
+  };
+
+  getFeedById(
+    _feedId: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, number, BigNumber] & {
+      _value: BigNumber;
+      _decimals: number;
+      _timestamp: BigNumber;
+    }
+  >;
+
+  getFeedByIdInWei(
+    _feedId: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber] & { _value: BigNumber; _timestamp: BigNumber }
+  >;
+
+  getFeedByIndex(
+    _index: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, number, BigNumber] & {
+      _value: BigNumber;
+      _decimals: number;
+      _timestamp: BigNumber;
+    }
+  >;
+
+  getFeedByIndexInWei(
+    _index: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber] & { _value: BigNumber; _timestamp: BigNumber }
+  >;
+
+  getFeedId(
+    _index: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  getFeedIndex(
+    _feedId: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  getFeedsById(
+    _feedIds: PromiseOrValue<BytesLike>[],
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber[], number[], BigNumber] & {
+      _values: BigNumber[];
+      _decimals: number[];
+      _timestamp: BigNumber;
+    }
+  >;
+
+  getFeedsByIdInWei(
+    _feedIds: PromiseOrValue<BytesLike>[],
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber[], BigNumber] & { _values: BigNumber[]; _timestamp: BigNumber }
+  >;
+
+  getFeedsByIndex(
+    _indices: PromiseOrValue<BigNumberish>[],
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber[], number[], BigNumber] & {
+      _values: BigNumber[];
+      _decimals: number[];
+      _timestamp: BigNumber;
+    }
+  >;
+
+  getFeedsByIndexInWei(
+    _indices: PromiseOrValue<BigNumberish>[],
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber[], BigNumber] & { _values: BigNumber[]; _timestamp: BigNumber }
+  >;
+
+  verifyFeedData(
+    _feedData: TestFtsoV2Interface.FeedDataWithProofStruct,
+    overrides?: CallOverrides
+  ): Promise<boolean>;
+
+  callStatic: {
+    getFeedById(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, number, BigNumber] & {
+        _value: BigNumber;
+        _decimals: number;
+        _timestamp: BigNumber;
+      }
+    >;
+
+    getFeedByIdInWei(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { _value: BigNumber; _timestamp: BigNumber }
+    >;
+
+    getFeedByIndex(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, number, BigNumber] & {
+        _value: BigNumber;
+        _decimals: number;
+        _timestamp: BigNumber;
+      }
+    >;
+
+    getFeedByIndexInWei(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { _value: BigNumber; _timestamp: BigNumber }
+    >;
+
+    getFeedId(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    getFeedIndex(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getFeedsById(
+      _feedIds: PromiseOrValue<BytesLike>[],
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber[], number[], BigNumber] & {
+        _values: BigNumber[];
+        _decimals: number[];
+        _timestamp: BigNumber;
+      }
+    >;
+
+    getFeedsByIdInWei(
+      _feedIds: PromiseOrValue<BytesLike>[],
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber[], BigNumber] & { _values: BigNumber[]; _timestamp: BigNumber }
+    >;
+
+    getFeedsByIndex(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber[], number[], BigNumber] & {
+        _values: BigNumber[];
+        _decimals: number[];
+        _timestamp: BigNumber;
+      }
+    >;
+
+    getFeedsByIndexInWei(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber[], BigNumber] & { _values: BigNumber[]; _timestamp: BigNumber }
+    >;
+
+    verifyFeedData(
+      _feedData: TestFtsoV2Interface.FeedDataWithProofStruct,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    getFeedById(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getFeedByIdInWei(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getFeedByIndex(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getFeedByIndexInWei(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getFeedId(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getFeedIndex(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getFeedsById(
+      _feedIds: PromiseOrValue<BytesLike>[],
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getFeedsByIdInWei(
+      _feedIds: PromiseOrValue<BytesLike>[],
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getFeedsByIndex(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getFeedsByIndexInWei(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    verifyFeedData(
+      _feedData: TestFtsoV2Interface.FeedDataWithProofStruct,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    getFeedById(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getFeedByIdInWei(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getFeedByIndex(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getFeedByIndexInWei(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getFeedId(
+      _index: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getFeedIndex(
+      _feedId: PromiseOrValue<BytesLike>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getFeedsById(
+      _feedIds: PromiseOrValue<BytesLike>[],
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getFeedsByIdInWei(
+      _feedIds: PromiseOrValue<BytesLike>[],
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getFeedsByIndex(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getFeedsByIndexInWei(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    verifyFeedData(
+      _feedData: TestFtsoV2Interface.FeedDataWithProofStruct,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/ftso/index.ts

@@ -0,0 +1,5 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as interface from "./interface";
+export type { interface };

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/ftso/interface/index.ts

@@ -0,0 +1,4 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { IIFtso } from "./IIFtso";

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/genesis/index.ts

@@ -0,0 +1,5 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as interface from "./interface";
+export type { interface };

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/genesis/interface/IFtsoGenesis.ts

@@ -0,0 +1,167 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../../../common";
+
+export interface IFtsoGenesisInterface extends utils.Interface {
+  functions: {
+    "revealPriceSubmitter(address,uint256,uint256,uint256)": FunctionFragment;
+    "wNatVotePowerCached(address,uint256)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic: "revealPriceSubmitter" | "wNatVotePowerCached"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "revealPriceSubmitter",
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "wNatVotePowerCached",
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "revealPriceSubmitter",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "wNatVotePowerCached",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface IFtsoGenesis extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IFtsoGenesisInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    revealPriceSubmitter(
+      _voter: PromiseOrValue<string>,
+      _epochId: PromiseOrValue<BigNumberish>,
+      _price: PromiseOrValue<BigNumberish>,
+      _wNatVP: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    wNatVotePowerCached(
+      _voter: PromiseOrValue<string>,
+      _epochId: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  revealPriceSubmitter(
+    _voter: PromiseOrValue<string>,
+    _epochId: PromiseOrValue<BigNumberish>,
+    _price: PromiseOrValue<BigNumberish>,
+    _wNatVP: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  wNatVotePowerCached(
+    _voter: PromiseOrValue<string>,
+    _epochId: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    revealPriceSubmitter(
+      _voter: PromiseOrValue<string>,
+      _epochId: PromiseOrValue<BigNumberish>,
+      _price: PromiseOrValue<BigNumberish>,
+      _wNatVP: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    wNatVotePowerCached(
+      _voter: PromiseOrValue<string>,
+      _epochId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    revealPriceSubmitter(
+      _voter: PromiseOrValue<string>,
+      _epochId: PromiseOrValue<BigNumberish>,
+      _price: PromiseOrValue<BigNumberish>,
+      _wNatVP: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    wNatVotePowerCached(
+      _voter: PromiseOrValue<string>,
+      _epochId: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    revealPriceSubmitter(
+      _voter: PromiseOrValue<string>,
+      _epochId: PromiseOrValue<BigNumberish>,
+      _price: PromiseOrValue<BigNumberish>,
+      _wNatVP: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    wNatVotePowerCached(
+      _voter: PromiseOrValue<string>,
+      _epochId: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/genesis/interface/IFtsoManagerGenesis.ts

@@ -0,0 +1,93 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "../../../../../common";
+
+export interface IFtsoManagerGenesisInterface extends utils.Interface {
+  functions: {
+    "getCurrentPriceEpochId()": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic: "getCurrentPriceEpochId"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "getCurrentPriceEpochId",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "getCurrentPriceEpochId",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface IFtsoManagerGenesis extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IFtsoManagerGenesisInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    getCurrentPriceEpochId(
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { _priceEpochId: BigNumber }>;
+  };
+
+  getCurrentPriceEpochId(overrides?: CallOverrides): Promise<BigNumber>;
+
+  callStatic: {
+    getCurrentPriceEpochId(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    getCurrentPriceEpochId(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    getCurrentPriceEpochId(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/genesis/interface/IFtsoRegistryGenesis.ts

@@ -0,0 +1,101 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../../../common";
+
+export interface IFtsoRegistryGenesisInterface extends utils.Interface {
+  functions: {
+    "getFtsos(uint256[])": FunctionFragment;
+  };
+
+  getFunction(nameOrSignatureOrTopic: "getFtsos"): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "getFtsos",
+    values: [PromiseOrValue<BigNumberish>[]]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "getFtsos", data: BytesLike): Result;
+
+  events: {};
+}
+
+export interface IFtsoRegistryGenesis extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IFtsoRegistryGenesisInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    getFtsos(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<[string[]] & { _ftsos: string[] }>;
+  };
+
+  getFtsos(
+    _indices: PromiseOrValue<BigNumberish>[],
+    overrides?: CallOverrides
+  ): Promise<string[]>;
+
+  callStatic: {
+    getFtsos(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<string[]>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    getFtsos(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    getFtsos(
+      _indices: PromiseOrValue<BigNumberish>[],
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/genesis/interface/index.ts

@@ -0,0 +1,6 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { IFtsoGenesis } from "./IFtsoGenesis";
+export type { IFtsoManagerGenesis } from "./IFtsoManagerGenesis";
+export type { IFtsoRegistryGenesis } from "./IFtsoRegistryGenesis";

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/index.ts

@@ -0,0 +1,58 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as ftso from "./ftso";
+export type { ftso };
+import type * as genesis from "./genesis";
+export type { genesis };
+import type * as token from "./token";
+export type { token };
+export type { FtsoV2Interface } from "./FtsoV2Interface";
+export type { IAddressBinder } from "./IAddressBinder";
+export type { IClaimSetupManager } from "./IClaimSetupManager";
+export type { IDelegationAccount } from "./IDelegationAccount";
+export type { IDistributionToDelegators } from "./IDistributionToDelegators";
+export type { IEntityManager } from "./IEntityManager";
+export type { IFastUpdateIncentiveManager } from "./IFastUpdateIncentiveManager";
+export type { IFastUpdater } from "./IFastUpdater";
+export type { IFastUpdatesConfiguration } from "./IFastUpdatesConfiguration";
+export type { IFeeCalculator } from "./IFeeCalculator";
+export type { IFlareAssetRegistry } from "./IFlareAssetRegistry";
+export type { IFlareContractRegistry } from "./IFlareContractRegistry";
+export type { IFlareSystemsCalculator } from "./IFlareSystemsCalculator";
+export type { IFlareSystemsManager } from "./IFlareSystemsManager";
+export type { IFtso } from "./IFtso";
+export type { IFtsoFeedDecimals } from "./IFtsoFeedDecimals";
+export type { IFtsoFeedIdConverter } from "./IFtsoFeedIdConverter";
+export type { IFtsoFeedPublisher } from "./IFtsoFeedPublisher";
+export type { IFtsoInflationConfigurations } from "./IFtsoInflationConfigurations";
+export type { IFtsoManager } from "./IFtsoManager";
+export type { IFtsoRegistry } from "./IFtsoRegistry";
+export type { IFtsoRewardManager } from "./IFtsoRewardManager";
+export type { IFtsoRewardOffersManager } from "./IFtsoRewardOffersManager";
+export type { IGenericRewardManager } from "./IGenericRewardManager";
+export type { IGovernanceSettings } from "./IGovernanceSettings";
+export type { IGovernanceVotePower } from "./IGovernanceVotePower";
+export type { IIncreaseManager } from "./IIncreaseManager";
+export type { IPChainStakeMirror } from "./IPChainStakeMirror";
+export type { IPChainStakeMirrorMultiSigVoting } from "./IPChainStakeMirrorMultiSigVoting";
+export type { IPChainVotePower } from "./IPChainVotePower";
+export type { IPollingFtso } from "./IPollingFtso";
+export type { IPriceSubmitter } from "./IPriceSubmitter";
+export type { IRNat } from "./IRNat";
+export type { IRNatAccount } from "./IRNatAccount";
+export type { IRandomProvider } from "./IRandomProvider";
+export type { IRelay } from "./IRelay";
+export type { IRewardManager } from "./IRewardManager";
+export type { ISubmission } from "./ISubmission";
+export type { IVPContractEvents } from "./IVPContractEvents";
+export type { IVPToken } from "./IVPToken";
+export type { IValidatorRegistry } from "./IValidatorRegistry";
+export type { IVoterRegistry } from "./IVoterRegistry";
+export type { IVoterWhitelister } from "./IVoterWhitelister";
+export type { IWNat } from "./IWNat";
+export type { IWNatDelegationFee } from "./IWNatDelegationFee";
+export type { ProtocolsV2Interface } from "./ProtocolsV2Interface";
+export type { RandomNumberV2Interface } from "./RandomNumberV2Interface";
+export type { RewardsV2Interface } from "./RewardsV2Interface";
+export type { TestFtsoV2Interface } from "./TestFtsoV2Interface";

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/token/index.ts

@@ -0,0 +1,5 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as interface from "./interface";
+export type { interface };

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/token/interface/IICleanable.ts

@@ -0,0 +1,166 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../../../common";
+
+export interface IICleanableInterface extends utils.Interface {
+  functions: {
+    "cleanupBlockNumber()": FunctionFragment;
+    "setCleanerContract(address)": FunctionFragment;
+    "setCleanupBlockNumber(uint256)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "cleanupBlockNumber"
+      | "setCleanerContract"
+      | "setCleanupBlockNumber"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "cleanupBlockNumber",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setCleanerContract",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setCleanupBlockNumber",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "cleanupBlockNumber",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "setCleanerContract",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "setCleanupBlockNumber",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface IICleanable extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IICleanableInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    cleanupBlockNumber(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    setCleanerContract(
+      _cleanerContract: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    setCleanupBlockNumber(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  cleanupBlockNumber(overrides?: CallOverrides): Promise<BigNumber>;
+
+  setCleanerContract(
+    _cleanerContract: PromiseOrValue<string>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  setCleanupBlockNumber(
+    _blockNumber: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    cleanupBlockNumber(overrides?: CallOverrides): Promise<BigNumber>;
+
+    setCleanerContract(
+      _cleanerContract: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    setCleanupBlockNumber(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    cleanupBlockNumber(overrides?: CallOverrides): Promise<BigNumber>;
+
+    setCleanerContract(
+      _cleanerContract: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    setCleanupBlockNumber(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    cleanupBlockNumber(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    setCleanerContract(
+      _cleanerContract: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    setCleanupBlockNumber(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/token/interface/IIGovernanceVotePower.ts

@@ -0,0 +1,525 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../../../common";
+
+export interface IIGovernanceVotePowerInterface extends utils.Interface {
+  functions: {
+    "delegate(address)": FunctionFragment;
+    "getCleanupBlockNumber()": FunctionFragment;
+    "getDelegateOfAt(address,uint256)": FunctionFragment;
+    "getDelegateOfAtNow(address)": FunctionFragment;
+    "getVotes(address)": FunctionFragment;
+    "ownerToken()": FunctionFragment;
+    "pChainStakeMirror()": FunctionFragment;
+    "setCleanerContract(address)": FunctionFragment;
+    "setCleanupBlockNumber(uint256)": FunctionFragment;
+    "undelegate()": FunctionFragment;
+    "updateAtTokenTransfer(address,address,uint256,uint256,uint256)": FunctionFragment;
+    "votePowerOfAt(address,uint256)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "delegate"
+      | "getCleanupBlockNumber"
+      | "getDelegateOfAt"
+      | "getDelegateOfAtNow"
+      | "getVotes"
+      | "ownerToken"
+      | "pChainStakeMirror"
+      | "setCleanerContract"
+      | "setCleanupBlockNumber"
+      | "undelegate"
+      | "updateAtTokenTransfer"
+      | "votePowerOfAt"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "delegate",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCleanupBlockNumber",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getDelegateOfAt",
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getDelegateOfAtNow",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getVotes",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "ownerToken",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "pChainStakeMirror",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setCleanerContract",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setCleanupBlockNumber",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "undelegate",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "updateAtTokenTransfer",
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "votePowerOfAt",
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "delegate", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getCleanupBlockNumber",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getDelegateOfAt",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getDelegateOfAtNow",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getVotes", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "ownerToken", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "pChainStakeMirror",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "setCleanerContract",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "setCleanupBlockNumber",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "undelegate", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "updateAtTokenTransfer",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "votePowerOfAt",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "DelegateChanged(address,address,address)": EventFragment;
+    "DelegateVotesChanged(address,uint256,uint256)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "DelegateChanged"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "DelegateVotesChanged"): EventFragment;
+}
+
+export interface DelegateChangedEventObject {
+  delegator: string;
+  fromDelegate: string;
+  toDelegate: string;
+}
+export type DelegateChangedEvent = TypedEvent<
+  [string, string, string],
+  DelegateChangedEventObject
+>;
+
+export type DelegateChangedEventFilter = TypedEventFilter<DelegateChangedEvent>;
+
+export interface DelegateVotesChangedEventObject {
+  delegate: string;
+  previousBalance: BigNumber;
+  newBalance: BigNumber;
+}
+export type DelegateVotesChangedEvent = TypedEvent<
+  [string, BigNumber, BigNumber],
+  DelegateVotesChangedEventObject
+>;
+
+export type DelegateVotesChangedEventFilter =
+  TypedEventFilter<DelegateVotesChangedEvent>;
+
+export interface IIGovernanceVotePower extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IIGovernanceVotePowerInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    delegate(
+      _to: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    getCleanupBlockNumber(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    getDelegateOfAt(
+      _who: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[string]>;
+
+    getDelegateOfAtNow(
+      _who: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[string]>;
+
+    getVotes(
+      _who: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    ownerToken(overrides?: CallOverrides): Promise<[string]>;
+
+    pChainStakeMirror(overrides?: CallOverrides): Promise<[string]>;
+
+    setCleanerContract(
+      _cleanerContract: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    setCleanupBlockNumber(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    undelegate(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    updateAtTokenTransfer(
+      _from: PromiseOrValue<string>,
+      _to: PromiseOrValue<string>,
+      _fromBalance: PromiseOrValue<BigNumberish>,
+      _toBalance: PromiseOrValue<BigNumberish>,
+      _amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    votePowerOfAt(
+      _who: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+  };
+
+  delegate(
+    _to: PromiseOrValue<string>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  getCleanupBlockNumber(overrides?: CallOverrides): Promise<BigNumber>;
+
+  getDelegateOfAt(
+    _who: PromiseOrValue<string>,
+    _blockNumber: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  getDelegateOfAtNow(
+    _who: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  getVotes(
+    _who: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  ownerToken(overrides?: CallOverrides): Promise<string>;
+
+  pChainStakeMirror(overrides?: CallOverrides): Promise<string>;
+
+  setCleanerContract(
+    _cleanerContract: PromiseOrValue<string>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  setCleanupBlockNumber(
+    _blockNumber: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  undelegate(
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  updateAtTokenTransfer(
+    _from: PromiseOrValue<string>,
+    _to: PromiseOrValue<string>,
+    _fromBalance: PromiseOrValue<BigNumberish>,
+    _toBalance: PromiseOrValue<BigNumberish>,
+    _amount: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  votePowerOfAt(
+    _who: PromiseOrValue<string>,
+    _blockNumber: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  callStatic: {
+    delegate(
+      _to: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    getCleanupBlockNumber(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getDelegateOfAt(
+      _who: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    getDelegateOfAtNow(
+      _who: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    getVotes(
+      _who: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    ownerToken(overrides?: CallOverrides): Promise<string>;
+
+    pChainStakeMirror(overrides?: CallOverrides): Promise<string>;
+
+    setCleanerContract(
+      _cleanerContract: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    setCleanupBlockNumber(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    undelegate(overrides?: CallOverrides): Promise<void>;
+
+    updateAtTokenTransfer(
+      _from: PromiseOrValue<string>,
+      _to: PromiseOrValue<string>,
+      _fromBalance: PromiseOrValue<BigNumberish>,
+      _toBalance: PromiseOrValue<BigNumberish>,
+      _amount: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    votePowerOfAt(
+      _who: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  filters: {
+    "DelegateChanged(address,address,address)"(
+      delegator?: PromiseOrValue<string> | null,
+      fromDelegate?: PromiseOrValue<string> | null,
+      toDelegate?: PromiseOrValue<string> | null
+    ): DelegateChangedEventFilter;
+    DelegateChanged(
+      delegator?: PromiseOrValue<string> | null,
+      fromDelegate?: PromiseOrValue<string> | null,
+      toDelegate?: PromiseOrValue<string> | null
+    ): DelegateChangedEventFilter;
+
+    "DelegateVotesChanged(address,uint256,uint256)"(
+      delegate?: PromiseOrValue<string> | null,
+      previousBalance?: null,
+      newBalance?: null
+    ): DelegateVotesChangedEventFilter;
+    DelegateVotesChanged(
+      delegate?: PromiseOrValue<string> | null,
+      previousBalance?: null,
+      newBalance?: null
+    ): DelegateVotesChangedEventFilter;
+  };
+
+  estimateGas: {
+    delegate(
+      _to: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    getCleanupBlockNumber(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getDelegateOfAt(
+      _who: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getDelegateOfAtNow(
+      _who: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getVotes(
+      _who: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    ownerToken(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pChainStakeMirror(overrides?: CallOverrides): Promise<BigNumber>;
+
+    setCleanerContract(
+      _cleanerContract: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    setCleanupBlockNumber(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    undelegate(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    updateAtTokenTransfer(
+      _from: PromiseOrValue<string>,
+      _to: PromiseOrValue<string>,
+      _fromBalance: PromiseOrValue<BigNumberish>,
+      _toBalance: PromiseOrValue<BigNumberish>,
+      _amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    votePowerOfAt(
+      _who: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    delegate(
+      _to: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    getCleanupBlockNumber(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getDelegateOfAt(
+      _who: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getDelegateOfAtNow(
+      _who: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getVotes(
+      _who: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    ownerToken(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pChainStakeMirror(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    setCleanerContract(
+      _cleanerContract: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    setCleanupBlockNumber(
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    undelegate(
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    updateAtTokenTransfer(
+      _from: PromiseOrValue<string>,
+      _to: PromiseOrValue<string>,
+      _fromBalance: PromiseOrValue<BigNumberish>,
+      _toBalance: PromiseOrValue<BigNumberish>,
+      _amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    votePowerOfAt(
+      _who: PromiseOrValue<string>,
+      _blockNumber: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@flarenetwork/flare-periphery-contracts/coston2/token/interface/index.ts

@@ -0,0 +1,7 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { IICleanable } from "./IICleanable";
+export type { IIGovernanceVotePower } from "./IIGovernanceVotePower";
+export type { IIVPContract } from "./IIVPContract";
+export type { IIVPToken } from "./IIVPToken";

typechain-types/@flarenetwork/flare-periphery-contracts/index.ts

@@ -0,0 +1,5 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as coston2 from "./coston2";
+export type { coston2 };

typechain-types/@flarenetwork/index.ts

@@ -0,0 +1,5 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as flarePeripheryContracts from "./flare-periphery-contracts";
+export type { flarePeripheryContracts };

typechain-types/@openzeppelin/contracts/index.ts

@@ -0,0 +1,5 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as token from "./token";
+export type { token };

typechain-types/@openzeppelin/contracts/token/ERC20/IERC20.ts

@@ -0,0 +1,342 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../../common";
+
+export interface IERC20Interface extends utils.Interface {
+  functions: {
+    "allowance(address,address)": FunctionFragment;
+    "approve(address,uint256)": FunctionFragment;
+    "balanceOf(address)": FunctionFragment;
+    "totalSupply()": FunctionFragment;
+    "transfer(address,uint256)": FunctionFragment;
+    "transferFrom(address,address,uint256)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "allowance"
+      | "approve"
+      | "balanceOf"
+      | "totalSupply"
+      | "transfer"
+      | "transferFrom"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "allowance",
+    values: [PromiseOrValue<string>, PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "approve",
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "balanceOf",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "totalSupply",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "transfer",
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "transferFrom",
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>
+    ]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "totalSupply",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "transferFrom",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "Approval(address,address,uint256)": EventFragment;
+    "Transfer(address,address,uint256)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
+}
+
+export interface ApprovalEventObject {
+  owner: string;
+  spender: string;
+  value: BigNumber;
+}
+export type ApprovalEvent = TypedEvent<
+  [string, string, BigNumber],
+  ApprovalEventObject
+>;
+
+export type ApprovalEventFilter = TypedEventFilter<ApprovalEvent>;
+
+export interface TransferEventObject {
+  from: string;
+  to: string;
+  value: BigNumber;
+}
+export type TransferEvent = TypedEvent<
+  [string, string, BigNumber],
+  TransferEventObject
+>;
+
+export type TransferEventFilter = TypedEventFilter<TransferEvent>;
+
+export interface IERC20 extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IERC20Interface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    allowance(
+      owner: PromiseOrValue<string>,
+      spender: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    approve(
+      spender: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    balanceOf(
+      account: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    transfer(
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    transferFrom(
+      from: PromiseOrValue<string>,
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  allowance(
+    owner: PromiseOrValue<string>,
+    spender: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  approve(
+    spender: PromiseOrValue<string>,
+    amount: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  balanceOf(
+    account: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
+
+  transfer(
+    to: PromiseOrValue<string>,
+    amount: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  transferFrom(
+    from: PromiseOrValue<string>,
+    to: PromiseOrValue<string>,
+    amount: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    allowance(
+      owner: PromiseOrValue<string>,
+      spender: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    approve(
+      spender: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    balanceOf(
+      account: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
+
+    transfer(
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    transferFrom(
+      from: PromiseOrValue<string>,
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+  };
+
+  filters: {
+    "Approval(address,address,uint256)"(
+      owner?: PromiseOrValue<string> | null,
+      spender?: PromiseOrValue<string> | null,
+      value?: null
+    ): ApprovalEventFilter;
+    Approval(
+      owner?: PromiseOrValue<string> | null,
+      spender?: PromiseOrValue<string> | null,
+      value?: null
+    ): ApprovalEventFilter;
+
+    "Transfer(address,address,uint256)"(
+      from?: PromiseOrValue<string> | null,
+      to?: PromiseOrValue<string> | null,
+      value?: null
+    ): TransferEventFilter;
+    Transfer(
+      from?: PromiseOrValue<string> | null,
+      to?: PromiseOrValue<string> | null,
+      value?: null
+    ): TransferEventFilter;
+  };
+
+  estimateGas: {
+    allowance(
+      owner: PromiseOrValue<string>,
+      spender: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    approve(
+      spender: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    balanceOf(
+      account: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
+
+    transfer(
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    transferFrom(
+      from: PromiseOrValue<string>,
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    allowance(
+      owner: PromiseOrValue<string>,
+      spender: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    approve(
+      spender: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    balanceOf(
+      account: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    totalSupply(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    transfer(
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    transferFrom(
+      from: PromiseOrValue<string>,
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.ts

@@ -0,0 +1,384 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../../../common";
+
+export interface IERC20MetadataInterface extends utils.Interface {
+  functions: {
+    "allowance(address,address)": FunctionFragment;
+    "approve(address,uint256)": FunctionFragment;
+    "balanceOf(address)": FunctionFragment;
+    "decimals()": FunctionFragment;
+    "name()": FunctionFragment;
+    "symbol()": FunctionFragment;
+    "totalSupply()": FunctionFragment;
+    "transfer(address,uint256)": FunctionFragment;
+    "transferFrom(address,address,uint256)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "allowance"
+      | "approve"
+      | "balanceOf"
+      | "decimals"
+      | "name"
+      | "symbol"
+      | "totalSupply"
+      | "transfer"
+      | "transferFrom"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "allowance",
+    values: [PromiseOrValue<string>, PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "approve",
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "balanceOf",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+  encodeFunctionData(functionFragment: "name", values?: undefined): string;
+  encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "totalSupply",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "transfer",
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "transferFrom",
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>
+    ]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "name", 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;
+
+  events: {
+    "Approval(address,address,uint256)": EventFragment;
+    "Transfer(address,address,uint256)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
+}
+
+export interface ApprovalEventObject {
+  owner: string;
+  spender: string;
+  value: BigNumber;
+}
+export type ApprovalEvent = TypedEvent<
+  [string, string, BigNumber],
+  ApprovalEventObject
+>;
+
+export type ApprovalEventFilter = TypedEventFilter<ApprovalEvent>;
+
+export interface TransferEventObject {
+  from: string;
+  to: string;
+  value: BigNumber;
+}
+export type TransferEvent = TypedEvent<
+  [string, string, BigNumber],
+  TransferEventObject
+>;
+
+export type TransferEventFilter = TypedEventFilter<TransferEvent>;
+
+export interface IERC20Metadata extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IERC20MetadataInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    allowance(
+      owner: PromiseOrValue<string>,
+      spender: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    approve(
+      spender: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    balanceOf(
+      account: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    decimals(overrides?: CallOverrides): Promise<[number]>;
+
+    name(overrides?: CallOverrides): Promise<[string]>;
+
+    symbol(overrides?: CallOverrides): Promise<[string]>;
+
+    totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    transfer(
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    transferFrom(
+      from: PromiseOrValue<string>,
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  allowance(
+    owner: PromiseOrValue<string>,
+    spender: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  approve(
+    spender: PromiseOrValue<string>,
+    amount: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  balanceOf(
+    account: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  decimals(overrides?: CallOverrides): Promise<number>;
+
+  name(overrides?: CallOverrides): Promise<string>;
+
+  symbol(overrides?: CallOverrides): Promise<string>;
+
+  totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
+
+  transfer(
+    to: PromiseOrValue<string>,
+    amount: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  transferFrom(
+    from: PromiseOrValue<string>,
+    to: PromiseOrValue<string>,
+    amount: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    allowance(
+      owner: PromiseOrValue<string>,
+      spender: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    approve(
+      spender: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    balanceOf(
+      account: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    decimals(overrides?: CallOverrides): Promise<number>;
+
+    name(overrides?: CallOverrides): Promise<string>;
+
+    symbol(overrides?: CallOverrides): Promise<string>;
+
+    totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
+
+    transfer(
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    transferFrom(
+      from: PromiseOrValue<string>,
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+  };
+
+  filters: {
+    "Approval(address,address,uint256)"(
+      owner?: PromiseOrValue<string> | null,
+      spender?: PromiseOrValue<string> | null,
+      value?: null
+    ): ApprovalEventFilter;
+    Approval(
+      owner?: PromiseOrValue<string> | null,
+      spender?: PromiseOrValue<string> | null,
+      value?: null
+    ): ApprovalEventFilter;
+
+    "Transfer(address,address,uint256)"(
+      from?: PromiseOrValue<string> | null,
+      to?: PromiseOrValue<string> | null,
+      value?: null
+    ): TransferEventFilter;
+    Transfer(
+      from?: PromiseOrValue<string> | null,
+      to?: PromiseOrValue<string> | null,
+      value?: null
+    ): TransferEventFilter;
+  };
+
+  estimateGas: {
+    allowance(
+      owner: PromiseOrValue<string>,
+      spender: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    approve(
+      spender: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    balanceOf(
+      account: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    decimals(overrides?: CallOverrides): Promise<BigNumber>;
+
+    name(overrides?: CallOverrides): Promise<BigNumber>;
+
+    symbol(overrides?: CallOverrides): Promise<BigNumber>;
+
+    totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
+
+    transfer(
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    transferFrom(
+      from: PromiseOrValue<string>,
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    allowance(
+      owner: PromiseOrValue<string>,
+      spender: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    approve(
+      spender: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    balanceOf(
+      account: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    decimals(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    name(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    symbol(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    totalSupply(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    transfer(
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    transferFrom(
+      from: PromiseOrValue<string>,
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/@openzeppelin/contracts/token/ERC20/extensions/index.ts

@@ -0,0 +1,4 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { IERC20Metadata } from "./IERC20Metadata";

typechain-types/@openzeppelin/contracts/token/ERC20/index.ts

@@ -0,0 +1,6 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as extensions from "./extensions";
+export type { extensions };
+export type { IERC20 } from "./IERC20";

typechain-types/@openzeppelin/contracts/token/index.ts

@@ -0,0 +1,5 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as erc20 from "./ERC20";
+export type { erc20 };

typechain-types/@openzeppelin/index.ts

@@ -0,0 +1,5 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as contracts from "./contracts";
+export type { contracts };

typechain-types/common.ts

@@ -0,0 +1,46 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type { Listener } from "@ethersproject/providers";
+import type { Event, EventFilter } from "ethers";
+
+export interface TypedEvent<
+  TArgsArray extends Array<any> = any,
+  TArgsObject = any
+> extends Event {
+  args: TArgsArray & TArgsObject;
+}
+
+export interface TypedEventFilter<_TEvent extends TypedEvent>
+  extends EventFilter {}
+
+export interface TypedListener<TEvent extends TypedEvent> {
+  (...listenerArg: [...__TypechainArgsArray<TEvent>, TEvent]): void;
+}
+
+type __TypechainArgsArray<T> = T extends TypedEvent<infer U> ? U : never;
+
+export interface OnEvent<TRes> {
+  <TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>,
+    listener: TypedListener<TEvent>
+  ): TRes;
+  (eventName: string, listener: Listener): TRes;
+}
+
+export type MinEthersFactory<C, ARGS> = {
+  deploy(...a: ARGS[]): Promise<C>;
+};
+
+export type GetContractTypeFromFactory<F> = F extends MinEthersFactory<
+  infer C,
+  any
+>
+  ? C
+  : never;
+
+export type GetARGsTypeFromFactory<F> = F extends MinEthersFactory<any, any>
+  ? Parameters<F["deploy"]>
+  : never;
+
+export type PromiseOrValue<T> = T | Promise<T>;

typechain-types/contracts/Escrow.ts

@@ -0,0 +1,434 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PayableOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../common";
+
+export interface EscrowInterface extends utils.Interface {
+  functions: {
+    "approveEscrow(uint256)": FunctionFragment;
+    "createEscrow(address)": FunctionFragment;
+    "escrowCounter()": FunctionFragment;
+    "escrows(uint256)": FunctionFragment;
+    "getEscrowAmount(uint256)": FunctionFragment;
+    "getEscrowBuyer(uint256)": FunctionFragment;
+    "getEscrowBuyerApproved(uint256)": FunctionFragment;
+    "getEscrowIsComplete(uint256)": FunctionFragment;
+    "getEscrowSeller(uint256)": FunctionFragment;
+    "getEscrowSellerApproved(uint256)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "approveEscrow"
+      | "createEscrow"
+      | "escrowCounter"
+      | "escrows"
+      | "getEscrowAmount"
+      | "getEscrowBuyer"
+      | "getEscrowBuyerApproved"
+      | "getEscrowIsComplete"
+      | "getEscrowSeller"
+      | "getEscrowSellerApproved"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "approveEscrow",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "createEscrow",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "escrowCounter",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "escrows",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getEscrowAmount",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getEscrowBuyer",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getEscrowBuyerApproved",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getEscrowIsComplete",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getEscrowSeller",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getEscrowSellerApproved",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "approveEscrow",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "createEscrow",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "escrowCounter",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "escrows", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getEscrowAmount",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getEscrowBuyer",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getEscrowBuyerApproved",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getEscrowIsComplete",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getEscrowSeller",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getEscrowSellerApproved",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface Escrow extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: EscrowInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    approveEscrow(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    createEscrow(
+      _seller: PromiseOrValue<string>,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    escrowCounter(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    escrows(
+      arg0: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [string, string, BigNumber, boolean, boolean, boolean] & {
+        buyer: string;
+        seller: string;
+        amount: BigNumber;
+        buyerApproved: boolean;
+        sellerApproved: boolean;
+        isComplete: boolean;
+      }
+    >;
+
+    getEscrowAmount(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    getEscrowBuyer(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[string]>;
+
+    getEscrowBuyerApproved(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[boolean]>;
+
+    getEscrowIsComplete(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[boolean]>;
+
+    getEscrowSeller(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[string]>;
+
+    getEscrowSellerApproved(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[boolean]>;
+  };
+
+  approveEscrow(
+    escrowId: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  createEscrow(
+    _seller: PromiseOrValue<string>,
+    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  escrowCounter(overrides?: CallOverrides): Promise<BigNumber>;
+
+  escrows(
+    arg0: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<
+    [string, string, BigNumber, boolean, boolean, boolean] & {
+      buyer: string;
+      seller: string;
+      amount: BigNumber;
+      buyerApproved: boolean;
+      sellerApproved: boolean;
+      isComplete: boolean;
+    }
+  >;
+
+  getEscrowAmount(
+    escrowId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  getEscrowBuyer(
+    escrowId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  getEscrowBuyerApproved(
+    escrowId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<boolean>;
+
+  getEscrowIsComplete(
+    escrowId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<boolean>;
+
+  getEscrowSeller(
+    escrowId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  getEscrowSellerApproved(
+    escrowId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<boolean>;
+
+  callStatic: {
+    approveEscrow(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    createEscrow(
+      _seller: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    escrowCounter(overrides?: CallOverrides): Promise<BigNumber>;
+
+    escrows(
+      arg0: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [string, string, BigNumber, boolean, boolean, boolean] & {
+        buyer: string;
+        seller: string;
+        amount: BigNumber;
+        buyerApproved: boolean;
+        sellerApproved: boolean;
+        isComplete: boolean;
+      }
+    >;
+
+    getEscrowAmount(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getEscrowBuyer(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    getEscrowBuyerApproved(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    getEscrowIsComplete(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    getEscrowSeller(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    getEscrowSellerApproved(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    approveEscrow(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    createEscrow(
+      _seller: PromiseOrValue<string>,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    escrowCounter(overrides?: CallOverrides): Promise<BigNumber>;
+
+    escrows(
+      arg0: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getEscrowAmount(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getEscrowBuyer(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getEscrowBuyerApproved(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getEscrowIsComplete(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getEscrowSeller(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getEscrowSellerApproved(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    approveEscrow(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    createEscrow(
+      _seller: PromiseOrValue<string>,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    escrowCounter(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    escrows(
+      arg0: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getEscrowAmount(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getEscrowBuyer(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getEscrowBuyerApproved(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getEscrowIsComplete(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getEscrowSeller(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getEscrowSellerApproved(
+      escrowId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/contracts/EventManager.ts

@@ -0,0 +1,632 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PayableOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../common";
+
+export interface EventManagerInterface extends utils.Interface {
+  functions: {
+    "approveTicket(uint256,address,bool)": FunctionFragment;
+    "buyTicket(uint256)": FunctionFragment;
+    "centsToFlare(uint256)": FunctionFragment;
+    "createEvent(string,string,uint256,uint256,uint256,string[])": FunctionFragment;
+    "eventCounter()": FunctionFragment;
+    "events(uint256)": FunctionFragment;
+    "getEventImages(uint256)": FunctionFragment;
+    "getEventPriceFlare(uint256)": FunctionFragment;
+    "getEventTickets(uint256)": FunctionFragment;
+    "power(uint256,int8)": FunctionFragment;
+    "ticketCounter()": FunctionFragment;
+    "tickets(uint256)": FunctionFragment;
+    "transferTicket(uint256,address)": FunctionFragment;
+    "userTickets(address,uint256)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "approveTicket"
+      | "buyTicket"
+      | "centsToFlare"
+      | "createEvent"
+      | "eventCounter"
+      | "events"
+      | "getEventImages"
+      | "getEventPriceFlare"
+      | "getEventTickets"
+      | "power"
+      | "ticketCounter"
+      | "tickets"
+      | "transferTicket"
+      | "userTickets"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "approveTicket",
+    values: [
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<string>,
+      PromiseOrValue<boolean>
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "buyTicket",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "centsToFlare",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "createEvent",
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<BigNumberish>,
+      PromiseOrValue<string>[]
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "eventCounter",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "events",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getEventImages",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getEventPriceFlare",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getEventTickets",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "power",
+    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "ticketCounter",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "tickets",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "transferTicket",
+    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "userTickets",
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "approveTicket",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "buyTicket", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "centsToFlare",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "createEvent",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "eventCounter",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "events", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getEventImages",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getEventPriceFlare",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getEventTickets",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "power", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "ticketCounter",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "tickets", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "transferTicket",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "userTickets",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface EventManager extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: EventManagerInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    approveTicket(
+      _ticketId: PromiseOrValue<BigNumberish>,
+      _to: PromiseOrValue<string>,
+      _allowed: PromiseOrValue<boolean>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    buyTicket(
+      _eventId: PromiseOrValue<BigNumberish>,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    centsToFlare(
+      _cents: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { _flr: BigNumber }>;
+
+    createEvent(
+      _name: PromiseOrValue<string>,
+      _description: PromiseOrValue<string>,
+      _capacity: PromiseOrValue<BigNumberish>,
+      _ticketPrice: PromiseOrValue<BigNumberish>,
+      _eventDate: PromiseOrValue<BigNumberish>,
+      _images: PromiseOrValue<string>[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    eventCounter(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    events(
+      arg0: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [string, string, BigNumber, BigNumber, BigNumber, BigNumber, string] & {
+        name: string;
+        description: string;
+        capacity: BigNumber;
+        ticketsSold: BigNumber;
+        ticketPrice: BigNumber;
+        eventDate: BigNumber;
+        eventHost: string;
+      }
+    >;
+
+    getEventImages(
+      _eventId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[string[]]>;
+
+    getEventPriceFlare(
+      _eventId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { _flr: BigNumber }>;
+
+    getEventTickets(
+      _eventId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber[]]>;
+
+    power(
+      base: PromiseOrValue<BigNumberish>,
+      exponent: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    ticketCounter(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    tickets(
+      arg0: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [string, BigNumber, BigNumber] & {
+        holder: string;
+        boughtTime: BigNumber;
+        eventId: BigNumber;
+      }
+    >;
+
+    transferTicket(
+      _ticketId: PromiseOrValue<BigNumberish>,
+      _to: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    userTickets(
+      arg0: PromiseOrValue<string>,
+      arg1: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+  };
+
+  approveTicket(
+    _ticketId: PromiseOrValue<BigNumberish>,
+    _to: PromiseOrValue<string>,
+    _allowed: PromiseOrValue<boolean>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  buyTicket(
+    _eventId: PromiseOrValue<BigNumberish>,
+    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  centsToFlare(
+    _cents: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  createEvent(
+    _name: PromiseOrValue<string>,
+    _description: PromiseOrValue<string>,
+    _capacity: PromiseOrValue<BigNumberish>,
+    _ticketPrice: PromiseOrValue<BigNumberish>,
+    _eventDate: PromiseOrValue<BigNumberish>,
+    _images: PromiseOrValue<string>[],
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  eventCounter(overrides?: CallOverrides): Promise<BigNumber>;
+
+  events(
+    arg0: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<
+    [string, string, BigNumber, BigNumber, BigNumber, BigNumber, string] & {
+      name: string;
+      description: string;
+      capacity: BigNumber;
+      ticketsSold: BigNumber;
+      ticketPrice: BigNumber;
+      eventDate: BigNumber;
+      eventHost: string;
+    }
+  >;
+
+  getEventImages(
+    _eventId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string[]>;
+
+  getEventPriceFlare(
+    _eventId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  getEventTickets(
+    _eventId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber[]>;
+
+  power(
+    base: PromiseOrValue<BigNumberish>,
+    exponent: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  ticketCounter(overrides?: CallOverrides): Promise<BigNumber>;
+
+  tickets(
+    arg0: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<
+    [string, BigNumber, BigNumber] & {
+      holder: string;
+      boughtTime: BigNumber;
+      eventId: BigNumber;
+    }
+  >;
+
+  transferTicket(
+    _ticketId: PromiseOrValue<BigNumberish>,
+    _to: PromiseOrValue<string>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  userTickets(
+    arg0: PromiseOrValue<string>,
+    arg1: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  callStatic: {
+    approveTicket(
+      _ticketId: PromiseOrValue<BigNumberish>,
+      _to: PromiseOrValue<string>,
+      _allowed: PromiseOrValue<boolean>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    buyTicket(
+      _eventId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    centsToFlare(
+      _cents: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    createEvent(
+      _name: PromiseOrValue<string>,
+      _description: PromiseOrValue<string>,
+      _capacity: PromiseOrValue<BigNumberish>,
+      _ticketPrice: PromiseOrValue<BigNumberish>,
+      _eventDate: PromiseOrValue<BigNumberish>,
+      _images: PromiseOrValue<string>[],
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    eventCounter(overrides?: CallOverrides): Promise<BigNumber>;
+
+    events(
+      arg0: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [string, string, BigNumber, BigNumber, BigNumber, BigNumber, string] & {
+        name: string;
+        description: string;
+        capacity: BigNumber;
+        ticketsSold: BigNumber;
+        ticketPrice: BigNumber;
+        eventDate: BigNumber;
+        eventHost: string;
+      }
+    >;
+
+    getEventImages(
+      _eventId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<string[]>;
+
+    getEventPriceFlare(
+      _eventId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getEventTickets(
+      _eventId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber[]>;
+
+    power(
+      base: PromiseOrValue<BigNumberish>,
+      exponent: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    ticketCounter(overrides?: CallOverrides): Promise<BigNumber>;
+
+    tickets(
+      arg0: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<
+      [string, BigNumber, BigNumber] & {
+        holder: string;
+        boughtTime: BigNumber;
+        eventId: BigNumber;
+      }
+    >;
+
+    transferTicket(
+      _ticketId: PromiseOrValue<BigNumberish>,
+      _to: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    userTickets(
+      arg0: PromiseOrValue<string>,
+      arg1: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    approveTicket(
+      _ticketId: PromiseOrValue<BigNumberish>,
+      _to: PromiseOrValue<string>,
+      _allowed: PromiseOrValue<boolean>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    buyTicket(
+      _eventId: PromiseOrValue<BigNumberish>,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    centsToFlare(
+      _cents: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    createEvent(
+      _name: PromiseOrValue<string>,
+      _description: PromiseOrValue<string>,
+      _capacity: PromiseOrValue<BigNumberish>,
+      _ticketPrice: PromiseOrValue<BigNumberish>,
+      _eventDate: PromiseOrValue<BigNumberish>,
+      _images: PromiseOrValue<string>[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    eventCounter(overrides?: CallOverrides): Promise<BigNumber>;
+
+    events(
+      arg0: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getEventImages(
+      _eventId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getEventPriceFlare(
+      _eventId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getEventTickets(
+      _eventId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    power(
+      base: PromiseOrValue<BigNumberish>,
+      exponent: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    ticketCounter(overrides?: CallOverrides): Promise<BigNumber>;
+
+    tickets(
+      arg0: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    transferTicket(
+      _ticketId: PromiseOrValue<BigNumberish>,
+      _to: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    userTickets(
+      arg0: PromiseOrValue<string>,
+      arg1: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    approveTicket(
+      _ticketId: PromiseOrValue<BigNumberish>,
+      _to: PromiseOrValue<string>,
+      _allowed: PromiseOrValue<boolean>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    buyTicket(
+      _eventId: PromiseOrValue<BigNumberish>,
+      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    centsToFlare(
+      _cents: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    createEvent(
+      _name: PromiseOrValue<string>,
+      _description: PromiseOrValue<string>,
+      _capacity: PromiseOrValue<BigNumberish>,
+      _ticketPrice: PromiseOrValue<BigNumberish>,
+      _eventDate: PromiseOrValue<BigNumberish>,
+      _images: PromiseOrValue<string>[],
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    eventCounter(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    events(
+      arg0: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getEventImages(
+      _eventId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getEventPriceFlare(
+      _eventId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getEventTickets(
+      _eventId: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    power(
+      base: PromiseOrValue<BigNumberish>,
+      exponent: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    ticketCounter(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    tickets(
+      arg0: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    transferTicket(
+      _ticketId: PromiseOrValue<BigNumberish>,
+      _to: PromiseOrValue<string>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    userTickets(
+      arg0: PromiseOrValue<string>,
+      arg1: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/contracts/FlareOracle.sol/FtsoV2FeedConsumer.ts

@@ -0,0 +1,148 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../common";
+
+export interface FtsoV2FeedConsumerInterface extends utils.Interface {
+  functions: {
+    "feedIds(uint256)": FunctionFragment;
+    "getFtsoV2CurrentFeedValues()": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic: "feedIds" | "getFtsoV2CurrentFeedValues"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "feedIds",
+    values: [PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getFtsoV2CurrentFeedValues",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(functionFragment: "feedIds", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getFtsoV2CurrentFeedValues",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface FtsoV2FeedConsumer extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: FtsoV2FeedConsumerInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    feedIds(
+      arg0: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<[string]>;
+
+    getFtsoV2CurrentFeedValues(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber[], number[], BigNumber] & {
+        _feedValues: BigNumber[];
+        _decimals: number[];
+        _timestamp: BigNumber;
+      }
+    >;
+  };
+
+  feedIds(
+    arg0: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  getFtsoV2CurrentFeedValues(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber[], number[], BigNumber] & {
+      _feedValues: BigNumber[];
+      _decimals: number[];
+      _timestamp: BigNumber;
+    }
+  >;
+
+  callStatic: {
+    feedIds(
+      arg0: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    getFtsoV2CurrentFeedValues(
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber[], number[], BigNumber] & {
+        _feedValues: BigNumber[];
+        _decimals: number[];
+        _timestamp: BigNumber;
+      }
+    >;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    feedIds(
+      arg0: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getFtsoV2CurrentFeedValues(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    feedIds(
+      arg0: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getFtsoV2CurrentFeedValues(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

typechain-types/contracts/FlareOracle.sol/index.ts

@@ -0,0 +1,4 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { FtsoV2FeedConsumer } from "./FtsoV2FeedConsumer";

typechain-types/contracts/index.ts

@@ -0,0 +1,7 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as flareOracleSol from "./FlareOracle.sol";
+export type { flareOracleSol };
+export type { Escrow } from "./Escrow";
+export type { EventManager } from "./EventManager";

typechain-types/factories/@flarenetwork/flare-periphery-contracts/coston2/FtsoV2Interface__factory.ts

@@ -0,0 +1,334 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+import { Contract, Signer, utils } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import type {
+  FtsoV2Interface,
+  FtsoV2InterfaceInterface,
+} from "../../../../@flarenetwork/flare-periphery-contracts/coston2/FtsoV2Interface";
+
+const _abi = [
+  {
+    inputs: [
+      {
+        internalType: "bytes21",
+        name: "_feedId",
+        type: "bytes21",
+      },
+    ],
+    name: "getFeedById",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "_value",
+        type: "uint256",
+      },
+      {
+        internalType: "int8",
+        name: "_decimals",
+        type: "int8",
+      },
+      {
+        internalType: "uint64",
+        name: "_timestamp",
+        type: "uint64",
+      },
+    ],
+    stateMutability: "payable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes21",
+        name: "_feedId",
+        type: "bytes21",
+      },
+    ],
+    name: "getFeedByIdInWei",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "_value",
+        type: "uint256",
+      },
+      {
+        internalType: "uint64",
+        name: "_timestamp",
+        type: "uint64",
+      },
+    ],
+    stateMutability: "payable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_index",
+        type: "uint256",
+      },
+    ],
+    name: "getFeedByIndex",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "_value",
+        type: "uint256",
+      },
+      {
+        internalType: "int8",
+        name: "_decimals",
+        type: "int8",
+      },
+      {
+        internalType: "uint64",
+        name: "_timestamp",
+        type: "uint64",
+      },
+    ],
+    stateMutability: "payable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_index",
+        type: "uint256",
+      },
+    ],
+    name: "getFeedByIndexInWei",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "_value",
+        type: "uint256",
+      },
+      {
+        internalType: "uint64",
+        name: "_timestamp",
+        type: "uint64",
+      },
+    ],
+    stateMutability: "payable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_index",
+        type: "uint256",
+      },
+    ],
+    name: "getFeedId",
+    outputs: [
+      {
+        internalType: "bytes21",
+        name: "_feedId",
+        type: "bytes21",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes21",
+        name: "_feedId",
+        type: "bytes21",
+      },
+    ],
+    name: "getFeedIndex",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "_index",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes21[]",
+        name: "_feedIds",
+        type: "bytes21[]",
+      },
+    ],
+    name: "getFeedsById",
+    outputs: [
+      {
+        internalType: "uint256[]",
+        name: "_values",
+        type: "uint256[]",
+      },
+      {
+        internalType: "int8[]",
+        name: "_decimals",
+        type: "int8[]",
+      },
+      {
+        internalType: "uint64",
+        name: "_timestamp",
+        type: "uint64",
+      },
+    ],
+    stateMutability: "payable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes21[]",
+        name: "_feedIds",
+        type: "bytes21[]",
+      },
+    ],
+    name: "getFeedsByIdInWei",
+    outputs: [
+      {
+        internalType: "uint256[]",
+        name: "_values",
+        type: "uint256[]",
+      },
+      {
+        internalType: "uint64",
+        name: "_timestamp",
+        type: "uint64",
+      },
+    ],
+    stateMutability: "payable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256[]",
+        name: "_indices",
+        type: "uint256[]",
+      },
+    ],
+    name: "getFeedsByIndex",
+    outputs: [
+      {
+        internalType: "uint256[]",
+        name: "_values",
+        type: "uint256[]",
+      },
+      {
+        internalType: "int8[]",
+        name: "_decimals",
+        type: "int8[]",
+      },
+      {
+        internalType: "uint64",
+        name: "_timestamp",
+        type: "uint64",
+      },
+    ],
+    stateMutability: "payable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256[]",
+        name: "_indices",
+        type: "uint256[]",
+      },
+    ],
+    name: "getFeedsByIndexInWei",
+    outputs: [
+      {
+        internalType: "uint256[]",
+        name: "_values",
+        type: "uint256[]",
+      },
+      {
+        internalType: "uint64",
+        name: "_timestamp",
+        type: "uint64",
+      },
+    ],
+    stateMutability: "payable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: "bytes32[]",
+            name: "proof",
+            type: "bytes32[]",
+          },
+          {
+            components: [
+              {
+                internalType: "uint32",
+                name: "votingRoundId",
+                type: "uint32",
+              },
+              {
+                internalType: "bytes21",
+                name: "id",
+                type: "bytes21",
+              },
+              {
+                internalType: "int32",
+                name: "value",
+                type: "int32",
+              },
+              {
+                internalType: "uint16",
+                name: "turnoutBIPS",
+                type: "uint16",
+              },
+              {
+                internalType: "int8",
+                name: "decimals",
+                type: "int8",
+              },
+            ],
+            internalType: "struct FtsoV2Interface.FeedData",
+            name: "body",
+            type: "tuple",
+          },
+        ],
+        internalType: "struct FtsoV2Interface.FeedDataWithProof",
+        name: "_feedData",
+        type: "tuple",
+      },
+    ],
+    name: "verifyFeedData",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+] as const;
+
+export class FtsoV2Interface__factory {
+  static readonly abi = _abi;
+  static createInterface(): FtsoV2InterfaceInterface {
+    return new utils.Interface(_abi) as FtsoV2InterfaceInterface;
+  }
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): FtsoV2Interface {
+    return new Contract(address, _abi, signerOrProvider) as FtsoV2Interface;
+  }
+}

typechain-types/factories/@flarenetwork/flare-periphery-contracts/coston2/IAddressBinder__factory.ts

@@ -0,0 +1,136 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+import { Contract, Signer, utils } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import type {
+  IAddressBinder,
+  IAddressBinderInterface,
+} from "../../../../@flarenetwork/flare-periphery-contracts/coston2/IAddressBinder";
+
+const _abi = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "bytes",
+        name: "publicKey",
+        type: "bytes",
+      },
+      {
+        indexed: false,
+        internalType: "bytes20",
+        name: "pAddress",
+        type: "bytes20",
+      },
+      {
+        indexed: false,
+        internalType: "address",
+        name: "cAddress",
+        type: "address",
+      },
+    ],
+    name: "AddressesRegistered",
+    type: "event",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_cAddress",
+        type: "address",
+      },
+    ],
+    name: "cAddressToPAddress",
+    outputs: [
+      {
+        internalType: "bytes20",
+        name: "_pAddress",
+        type: "bytes20",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes20",
+        name: "_pAddress",
+        type: "bytes20",
+      },
+    ],
+    name: "pAddressToCAddress",
+    outputs: [
+      {
+        internalType: "address",
+        name: "_cAddress",
+        type: "address",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "_publicKey",
+        type: "bytes",
+      },
+      {
+        internalType: "bytes20",
+        name: "_pAddress",
+        type: "bytes20",
+      },
+      {
+        internalType: "address",
+        name: "_cAddress",
+        type: "address",
+      },
+    ],
+    name: "registerAddresses",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "_publicKey",
+        type: "bytes",
+      },
+    ],
+    name: "registerPublicKey",
+    outputs: [
+      {
+        internalType: "bytes20",
+        name: "_pAddress",
+        type: "bytes20",
+      },
+      {
+        internalType: "address",
+        name: "_cAddress",
+        type: "address",
+      },
+    ],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+] as const;
+
+export class IAddressBinder__factory {
+  static readonly abi = _abi;
+  static createInterface(): IAddressBinderInterface {
+    return new utils.Interface(_abi) as IAddressBinderInterface;
+  }
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): IAddressBinder {
+    return new Contract(address, _abi, signerOrProvider) as IAddressBinder;
+  }
+}

typechain-types/factories/@flarenetwork/flare-periphery-contracts/coston2/IClaimSetupManager__factory.ts

@@ -0,0 +1,680 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+import { Contract, Signer, utils } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import type {
+  IClaimSetupManager,
+  IClaimSetupManagerInterface,
+} from "../../../../@flarenetwork/flare-periphery-contracts/coston2/IClaimSetupManager";
+
+const _abi = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "owner",
+        type: "address",
+      },
+      {
+        indexed: false,
+        internalType: "address[]",
+        name: "recipients",
+        type: "address[]",
+      },
+    ],
+    name: "AllowedClaimRecipientsChanged",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "executor",
+        type: "address",
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "validFromRewardEpoch",
+        type: "uint256",
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "feeValueWei",
+        type: "uint256",
+      },
+    ],
+    name: "ClaimExecutorFeeValueChanged",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "owner",
+        type: "address",
+      },
+      {
+        indexed: false,
+        internalType: "address[]",
+        name: "executors",
+        type: "address[]",
+      },
+    ],
+    name: "ClaimExecutorsChanged",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "owner",
+        type: "address",
+      },
+      {
+        indexed: false,
+        internalType: "contract IDelegationAccount",
+        name: "delegationAccount",
+        type: "address",
+      },
+    ],
+    name: "DelegationAccountCreated",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "owner",
+        type: "address",
+      },
+      {
+        indexed: false,
+        internalType: "contract IDelegationAccount",
+        name: "delegationAccount",
+        type: "address",
+      },
+      {
+        indexed: false,
+        internalType: "bool",
+        name: "enabled",
+        type: "bool",
+      },
+    ],
+    name: "DelegationAccountUpdated",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "executor",
+        type: "address",
+      },
+    ],
+    name: "ExecutorRegistered",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "executor",
+        type: "address",
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "validFromRewardEpoch",
+        type: "uint256",
+      },
+    ],
+    name: "ExecutorUnregistered",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "maxFeeValueWei",
+        type: "uint256",
+      },
+    ],
+    name: "MaxFeeSet",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "minFeeValueWei",
+        type: "uint256",
+      },
+    ],
+    name: "MinFeeSet",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "registerExecutorFeeValueWei",
+        type: "uint256",
+      },
+    ],
+    name: "RegisterExecutorFeeSet",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "owner",
+        type: "address",
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "excessAmount",
+        type: "uint256",
+      },
+    ],
+    name: "SetExecutorsExcessAmountRefunded",
+    type: "event",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_owner",
+        type: "address",
+      },
+    ],
+    name: "accountToDelegationAccount",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_rewardOwner",
+        type: "address",
+      },
+    ],
+    name: "allowedClaimRecipients",
+    outputs: [
+      {
+        internalType: "address[]",
+        name: "",
+        type: "address[]",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address[]",
+        name: "_delegatees",
+        type: "address[]",
+      },
+      {
+        internalType: "uint256[]",
+        name: "_bips",
+        type: "uint256[]",
+      },
+    ],
+    name: "batchDelegate",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_owner",
+        type: "address",
+      },
+    ],
+    name: "claimExecutors",
+    outputs: [
+      {
+        internalType: "address[]",
+        name: "",
+        type: "address[]",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_to",
+        type: "address",
+      },
+      {
+        internalType: "uint256",
+        name: "_bips",
+        type: "uint256",
+      },
+    ],
+    name: "delegate",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_to",
+        type: "address",
+      },
+    ],
+    name: "delegateGovernance",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "disableDelegationAccount",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "enableDelegationAccount",
+    outputs: [
+      {
+        internalType: "contract IDelegationAccount",
+        name: "",
+        type: "address",
+      },
+    ],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_owner",
+        type: "address",
+      },
+    ],
+    name: "getDelegationAccountData",
+    outputs: [
+      {
+        internalType: "contract IDelegationAccount",
+        name: "_delegationAccount",
+        type: "address",
+      },
+      {
+        internalType: "bool",
+        name: "_enabled",
+        type: "bool",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_executor",
+        type: "address",
+      },
+    ],
+    name: "getExecutorCurrentFeeValue",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_executor",
+        type: "address",
+      },
+      {
+        internalType: "uint256",
+        name: "_rewardEpoch",
+        type: "uint256",
+      },
+    ],
+    name: "getExecutorFeeValue",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_executor",
+        type: "address",
+      },
+    ],
+    name: "getExecutorInfo",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "_registered",
+        type: "bool",
+      },
+      {
+        internalType: "uint256",
+        name: "_currentFeeValue",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_executor",
+        type: "address",
+      },
+    ],
+    name: "getExecutorScheduledFeeValueChanges",
+    outputs: [
+      {
+        internalType: "uint256[]",
+        name: "_feeValue",
+        type: "uint256[]",
+      },
+      {
+        internalType: "uint256[]",
+        name: "_validFromEpoch",
+        type: "uint256[]",
+      },
+      {
+        internalType: "bool[]",
+        name: "_fixed",
+        type: "bool[]",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_start",
+        type: "uint256",
+      },
+      {
+        internalType: "uint256",
+        name: "_end",
+        type: "uint256",
+      },
+    ],
+    name: "getRegisteredExecutors",
+    outputs: [
+      {
+        internalType: "address[]",
+        name: "_registeredExecutors",
+        type: "address[]",
+      },
+      {
+        internalType: "uint256",
+        name: "_totalLength",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_owner",
+        type: "address",
+      },
+      {
+        internalType: "address",
+        name: "_executor",
+        type: "address",
+      },
+    ],
+    name: "isClaimExecutor",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_feeValue",
+        type: "uint256",
+      },
+    ],
+    name: "registerExecutor",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "payable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_who",
+        type: "address",
+      },
+      {
+        internalType: "uint256",
+        name: "_blockNumber",
+        type: "uint256",
+      },
+    ],
+    name: "revokeDelegationAt",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address[]",
+        name: "_recipients",
+        type: "address[]",
+      },
+    ],
+    name: "setAllowedClaimRecipients",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address[]",
+        name: "_executors",
+        type: "address[]",
+      },
+      {
+        internalType: "bool",
+        name: "_enableDelegationAccount",
+        type: "bool",
+      },
+    ],
+    name: "setAutoClaiming",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address[]",
+        name: "_executors",
+        type: "address[]",
+      },
+    ],
+    name: "setClaimExecutors",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "contract IERC20",
+        name: "_token",
+        type: "address",
+      },
+      {
+        internalType: "uint256",
+        name: "_amount",
+        type: "uint256",
+      },
+    ],
+    name: "transferExternalToken",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "undelegateAll",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "undelegateGovernance",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "unregisterExecutor",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_feeValue",
+        type: "uint256",
+      },
+    ],
+    name: "updateExecutorFeeValue",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_amount",
+        type: "uint256",
+      },
+    ],
+    name: "withdraw",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+] as const;
+
+export class IClaimSetupManager__factory {
+  static readonly abi = _abi;
+  static createInterface(): IClaimSetupManagerInterface {
+    return new utils.Interface(_abi) as IClaimSetupManagerInterface;
+  }
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): IClaimSetupManager {
+    return new Contract(address, _abi, signerOrProvider) as IClaimSetupManager;
+  }
+}

typechain-types/factories/@flarenetwork/flare-periphery-contracts/coston2/IDelegationAccount__factory.ts

@@ -0,0 +1,159 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+import { Contract, Signer, utils } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import type {
+  IDelegationAccount,
+  IDelegationAccountInterface,
+} from "../../../../@flarenetwork/flare-periphery-contracts/coston2/IDelegationAccount";
+
+const _abi = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "to",
+        type: "address",
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "bips",
+        type: "uint256",
+      },
+    ],
+    name: "DelegateFtso",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "to",
+        type: "address",
+      },
+    ],
+    name: "DelegateGovernance",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "executor",
+        type: "address",
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256",
+      },
+    ],
+    name: "ExecutorFeePaid",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "contract IERC20",
+        name: "token",
+        type: "address",
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256",
+      },
+    ],
+    name: "ExternalTokenTransferred",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "owner",
+        type: "address",
+      },
+      {
+        indexed: false,
+        internalType: "contract IClaimSetupManager",
+        name: "manager",
+        type: "address",
+      },
+    ],
+    name: "Initialize",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "to",
+        type: "address",
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "blockNumber",
+        type: "uint256",
+      },
+    ],
+    name: "RevokeFtso",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [],
+    name: "UndelegateAllFtso",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [],
+    name: "UndelegateGovernance",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256",
+      },
+    ],
+    name: "WithdrawToOwner",
+    type: "event",
+  },
+] as const;
+
+export class IDelegationAccount__factory {
+  static readonly abi = _abi;
+  static createInterface(): IDelegationAccountInterface {
+    return new utils.Interface(_abi) as IDelegationAccountInterface;
+  }
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): IDelegationAccount {
+    return new Contract(address, _abi, signerOrProvider) as IDelegationAccount;
+  }
+}

typechain-types/factories/@flarenetwork/flare-periphery-contracts/coston2/IDistributionToDelegators__factory.ts

@@ -0,0 +1,277 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+import { Contract, Signer, utils } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import type {
+  IDistributionToDelegators,
+  IDistributionToDelegatorsInterface,
+} from "../../../../@flarenetwork/flare-periphery-contracts/coston2/IDistributionToDelegators";
+
+const _abi = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "whoClaimed",
+        type: "address",
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "sentTo",
+        type: "address",
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "month",
+        type: "uint256",
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "amountWei",
+        type: "uint256",
+      },
+    ],
+    name: "AccountClaimed",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "theAccount",
+        type: "address",
+      },
+      {
+        indexed: false,
+        internalType: "bool",
+        name: "confirmed",
+        type: "bool",
+      },
+    ],
+    name: "AccountOptOut",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "entitlementStartTs",
+        type: "uint256",
+      },
+    ],
+    name: "EntitlementStart",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "bool",
+        name: "useGoodRandom",
+        type: "bool",
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "maxWaitForGoodRandomSeconds",
+        type: "uint256",
+      },
+    ],
+    name: "UseGoodRandomSet",
+    type: "event",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address[]",
+        name: "_rewardOwners",
+        type: "address[]",
+      },
+      {
+        internalType: "uint256",
+        name: "_month",
+        type: "uint256",
+      },
+    ],
+    name: "autoClaim",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_rewardOwner",
+        type: "address",
+      },
+      {
+        internalType: "address",
+        name: "_recipient",
+        type: "address",
+      },
+      {
+        internalType: "uint256",
+        name: "_month",
+        type: "uint256",
+      },
+      {
+        internalType: "bool",
+        name: "_wrap",
+        type: "bool",
+      },
+    ],
+    name: "claim",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "_rewardAmount",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_month",
+        type: "uint256",
+      },
+    ],
+    name: "getClaimableAmount",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "_amountWei",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_account",
+        type: "address",
+      },
+      {
+        internalType: "uint256",
+        name: "_month",
+        type: "uint256",
+      },
+    ],
+    name: "getClaimableAmountOf",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "_amountWei",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "getClaimableMonths",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "_startMonth",
+        type: "uint256",
+      },
+      {
+        internalType: "uint256",
+        name: "_endMonth",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "getCurrentMonth",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "_currentMonth",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "getMonthToExpireNext",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "_monthToExpireNext",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_rewardOwner",
+        type: "address",
+      },
+    ],
+    name: "nextClaimableMonth",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "optOutOfAirdrop",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+] as const;
+
+export class IDistributionToDelegators__factory {
+  static readonly abi = _abi;
+  static createInterface(): IDistributionToDelegatorsInterface {
+    return new utils.Interface(_abi) as IDistributionToDelegatorsInterface;
+  }
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): IDistributionToDelegators {
+    return new Contract(
+      address,
+      _abi,
+      signerOrProvider
+    ) as IDistributionToDelegators;
+  }
+}

typechain-types/factories/@flarenetwork/flare-periphery-contracts/coston2/IEntityManager__factory.ts

@@ -0,0 +1,814 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+import { Contract, Signer, utils } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import type {
+  IEntityManager,
+  IEntityManagerInterface,
+} from "../../../../@flarenetwork/flare-periphery-contracts/coston2/IEntityManager";
+
+const _abi = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "voter",
+        type: "address",
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "delegationAddress",
+        type: "address",
+      },
+    ],
+    name: "DelegationAddressProposed",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "voter",
+        type: "address",
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "delegationAddress",
+        type: "address",
+      },
+    ],
+    name: "DelegationAddressRegistrationConfirmed",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "maxNodeIdsPerEntity",
+        type: "uint256",
+      },
+    ],
+    name: "MaxNodeIdsPerEntitySet",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "voter",
+        type: "address",
+      },
+      {
+        indexed: true,
+        internalType: "bytes20",
+        name: "nodeId",
+        type: "bytes20",
+      },
+    ],
+    name: "NodeIdRegistered",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "voter",
+        type: "address",
+      },
+      {
+        indexed: true,
+        internalType: "bytes20",
+        name: "nodeId",
+        type: "bytes20",
+      },
+    ],
+    name: "NodeIdUnregistered",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "voter",
+        type: "address",
+      },
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "part1",
+        type: "bytes32",
+      },
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "part2",
+        type: "bytes32",
+      },
+    ],
+    name: "PublicKeyRegistered",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "voter",
+        type: "address",
+      },
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "part1",
+        type: "bytes32",
+      },
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "part2",
+        type: "bytes32",
+      },
+    ],
+    name: "PublicKeyUnregistered",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "voter",
+        type: "address",
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "signingPolicyAddress",
+        type: "address",
+      },
+    ],
+    name: "SigningPolicyAddressProposed",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "voter",
+        type: "address",
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "signingPolicyAddress",
+        type: "address",
+      },
+    ],
+    name: "SigningPolicyAddressRegistrationConfirmed",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "voter",
+        type: "address",
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "submitAddress",
+        type: "address",
+      },
+    ],
+    name: "SubmitAddressProposed",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "voter",
+        type: "address",
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "submitAddress",
+        type: "address",
+      },
+    ],
+    name: "SubmitAddressRegistrationConfirmed",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "voter",
+        type: "address",
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "submitSignaturesAddress",
+        type: "address",
+      },
+    ],
+    name: "SubmitSignaturesAddressProposed",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "voter",
+        type: "address",
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "submitSignaturesAddress",
+        type: "address",
+      },
+    ],
+    name: "SubmitSignaturesAddressRegistrationConfirmed",
+    type: "event",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_voter",
+        type: "address",
+      },
+    ],
+    name: "confirmDelegationAddressRegistration",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_voter",
+        type: "address",
+      },
+    ],
+    name: "confirmSigningPolicyAddressRegistration",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_voter",
+        type: "address",
+      },
+    ],
+    name: "confirmSubmitAddressRegistration",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_voter",
+        type: "address",
+      },
+    ],
+    name: "confirmSubmitSignaturesAddressRegistration",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_voter",
+        type: "address",
+      },
+    ],
+    name: "getDelegationAddressOf",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_voter",
+        type: "address",
+      },
+      {
+        internalType: "uint256",
+        name: "_blockNumber",
+        type: "uint256",
+      },
+    ],
+    name: "getDelegationAddressOfAt",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_voter",
+        type: "address",
+      },
+    ],
+    name: "getNodeIdsOf",
+    outputs: [
+      {
+        internalType: "bytes20[]",
+        name: "",
+        type: "bytes20[]",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_voter",
+        type: "address",
+      },
+      {
+        internalType: "uint256",
+        name: "_blockNumber",
+        type: "uint256",
+      },
+    ],
+    name: "getNodeIdsOfAt",
+    outputs: [
+      {
+        internalType: "bytes20[]",
+        name: "",
+        type: "bytes20[]",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_voter",
+        type: "address",
+      },
+    ],
+    name: "getPublicKeyOf",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32",
+      },
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_voter",
+        type: "address",
+      },
+      {
+        internalType: "uint256",
+        name: "_blockNumber",
+        type: "uint256",
+      },
+    ],
+    name: "getPublicKeyOfAt",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32",
+      },
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_voter",
+        type: "address",
+      },
+    ],
+    name: "getVoterAddresses",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "address",
+            name: "submitAddress",
+            type: "address",
+          },
+          {
+            internalType: "address",
+            name: "submitSignaturesAddress",
+            type: "address",
+          },
+          {
+            internalType: "address",
+            name: "signingPolicyAddress",
+            type: "address",
+          },
+        ],
+        internalType: "struct IEntityManager.VoterAddresses",
+        name: "_addresses",
+        type: "tuple",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_voter",
+        type: "address",
+      },
+      {
+        internalType: "uint256",
+        name: "_blockNumber",
+        type: "uint256",
+      },
+    ],
+    name: "getVoterAddressesAt",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "address",
+            name: "submitAddress",
+            type: "address",
+          },
+          {
+            internalType: "address",
+            name: "submitSignaturesAddress",
+            type: "address",
+          },
+          {
+            internalType: "address",
+            name: "signingPolicyAddress",
+            type: "address",
+          },
+        ],
+        internalType: "struct IEntityManager.VoterAddresses",
+        name: "_addresses",
+        type: "tuple",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_delegationAddress",
+        type: "address",
+      },
+      {
+        internalType: "uint256",
+        name: "_blockNumber",
+        type: "uint256",
+      },
+    ],
+    name: "getVoterForDelegationAddress",
+    outputs: [
+      {
+        internalType: "address",
+        name: "_voter",
+        type: "address",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes20",
+        name: "_nodeId",
+        type: "bytes20",
+      },
+      {
+        internalType: "uint256",
+        name: "_blockNumber",
+        type: "uint256",
+      },
+    ],
+    name: "getVoterForNodeId",
+    outputs: [
+      {
+        internalType: "address",
+        name: "_voter",
+        type: "address",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "_part1",
+        type: "bytes32",
+      },
+      {
+        internalType: "bytes32",
+        name: "_part2",
+        type: "bytes32",
+      },
+      {
+        internalType: "uint256",
+        name: "_blockNumber",
+        type: "uint256",
+      },
+    ],
+    name: "getVoterForPublicKey",
+    outputs: [
+      {
+        internalType: "address",
+        name: "_voter",
+        type: "address",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_signingPolicyAddress",
+        type: "address",
+      },
+      {
+        internalType: "uint256",
+        name: "_blockNumber",
+        type: "uint256",
+      },
+    ],
+    name: "getVoterForSigningPolicyAddress",
+    outputs: [
+      {
+        internalType: "address",
+        name: "_voter",
+        type: "address",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_submitAddress",
+        type: "address",
+      },
+      {
+        internalType: "uint256",
+        name: "_blockNumber",
+        type: "uint256",
+      },
+    ],
+    name: "getVoterForSubmitAddress",
+    outputs: [
+      {
+        internalType: "address",
+        name: "_voter",
+        type: "address",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_submitSignaturesAddress",
+        type: "address",
+      },
+      {
+        internalType: "uint256",
+        name: "_blockNumber",
+        type: "uint256",
+      },
+    ],
+    name: "getVoterForSubmitSignaturesAddress",
+    outputs: [
+      {
+        internalType: "address",
+        name: "_voter",
+        type: "address",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_delegationAddress",
+        type: "address",
+      },
+    ],
+    name: "proposeDelegationAddress",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_signingPolicyAddress",
+        type: "address",
+      },
+    ],
+    name: "proposeSigningPolicyAddress",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_submitAddress",
+        type: "address",
+      },
+    ],
+    name: "proposeSubmitAddress",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_submitSignaturesAddress",
+        type: "address",
+      },
+    ],
+    name: "proposeSubmitSignaturesAddress",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes20",
+        name: "_nodeId",
+        type: "bytes20",
+      },
+      {
+        internalType: "bytes",
+        name: "_certificateRaw",
+        type: "bytes",
+      },
+      {
+        internalType: "bytes",
+        name: "_signature",
+        type: "bytes",
+      },
+    ],
+    name: "registerNodeId",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "_part1",
+        type: "bytes32",
+      },
+      {
+        internalType: "bytes32",
+        name: "_part2",
+        type: "bytes32",
+      },
+      {
+        internalType: "bytes",
+        name: "_verificationData",
+        type: "bytes",
+      },
+    ],
+    name: "registerPublicKey",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes20",
+        name: "_nodeId",
+        type: "bytes20",
+      },
+    ],
+    name: "unregisterNodeId",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "unregisterPublicKey",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+] as const;
+
+export class IEntityManager__factory {
+  static readonly abi = _abi;
+  static createInterface(): IEntityManagerInterface {
+    return new utils.Interface(_abi) as IEntityManagerInterface;
+  }
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): IEntityManager {
+    return new Contract(address, _abi, signerOrProvider) as IEntityManager;
+  }
+}

typechain-types/factories/@flarenetwork/flare-periphery-contracts/coston2/IFastUpdateIncentiveManager__factory.ts

@@ -0,0 +1,258 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+import { Contract, Signer, utils } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import type {
+  IFastUpdateIncentiveManager,
+  IFastUpdateIncentiveManagerInterface,
+} from "../../../../@flarenetwork/flare-periphery-contracts/coston2/IFastUpdateIncentiveManager";
+
+const _abi = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint24",
+        name: "rewardEpochId",
+        type: "uint24",
+      },
+      {
+        indexed: false,
+        internalType: "Range",
+        name: "rangeIncrease",
+        type: "uint256",
+      },
+      {
+        indexed: false,
+        internalType: "SampleSize",
+        name: "sampleSizeIncrease",
+        type: "uint256",
+      },
+      {
+        indexed: false,
+        internalType: "Fee",
+        name: "offerAmount",
+        type: "uint256",
+      },
+    ],
+    name: "IncentiveOffered",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint24",
+        name: "rewardEpochId",
+        type: "uint24",
+      },
+      {
+        components: [
+          {
+            internalType: "bytes21",
+            name: "feedId",
+            type: "bytes21",
+          },
+          {
+            internalType: "uint32",
+            name: "rewardBandValue",
+            type: "uint32",
+          },
+          {
+            internalType: "uint24",
+            name: "inflationShare",
+            type: "uint24",
+          },
+        ],
+        indexed: false,
+        internalType: "struct IFastUpdatesConfiguration.FeedConfiguration[]",
+        name: "feedConfigurations",
+        type: "tuple[]",
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256",
+      },
+    ],
+    name: "InflationRewardsOffered",
+    type: "event",
+  },
+  {
+    inputs: [],
+    name: "getBaseScale",
+    outputs: [
+      {
+        internalType: "Scale",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "getCurrentSampleSizeIncreasePrice",
+    outputs: [
+      {
+        internalType: "Fee",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "getExpectedSampleSize",
+    outputs: [
+      {
+        internalType: "SampleSize",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "getIncentiveDuration",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "getPrecision",
+    outputs: [
+      {
+        internalType: "Precision",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "getRange",
+    outputs: [
+      {
+        internalType: "Range",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "getScale",
+    outputs: [
+      {
+        internalType: "Scale",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: "Range",
+            name: "rangeIncrease",
+            type: "uint256",
+          },
+          {
+            internalType: "Range",
+            name: "rangeLimit",
+            type: "uint256",
+          },
+        ],
+        internalType: "struct IFastUpdateIncentiveManager.IncentiveOffer",
+        name: "_offer",
+        type: "tuple",
+      },
+    ],
+    name: "offerIncentive",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "rangeIncreaseLimit",
+    outputs: [
+      {
+        internalType: "Range",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "rangeIncreasePrice",
+    outputs: [
+      {
+        internalType: "Fee",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "sampleIncreaseLimit",
+    outputs: [
+      {
+        internalType: "SampleSize",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+] as const;
+
+export class IFastUpdateIncentiveManager__factory {
+  static readonly abi = _abi;
+  static createInterface(): IFastUpdateIncentiveManagerInterface {
+    return new utils.Interface(_abi) as IFastUpdateIncentiveManagerInterface;
+  }
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): IFastUpdateIncentiveManager {
+    return new Contract(
+      address,
+      _abi,
+      signerOrProvider
+    ) as IFastUpdateIncentiveManager;
+  }
+}

typechain-types/factories/@flarenetwork/flare-periphery-contracts/coston2/IFastUpdater__factory.ts

@@ -0,0 +1,378 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+import { Contract, Signer, utils } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import type {
+  IFastUpdater,
+  IFastUpdaterInterface,
+} from "../../../../@flarenetwork/flare-periphery-contracts/coston2/IFastUpdater";
+
+const _abi = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "index",
+        type: "uint256",
+      },
+    ],
+    name: "FastUpdateFeedRemoved",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "votingRoundId",
+        type: "uint256",
+      },
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "index",
+        type: "uint256",
+      },
+      {
+        indexed: true,
+        internalType: "bytes21",
+        name: "id",
+        type: "bytes21",
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "value",
+        type: "uint256",
+      },
+      {
+        indexed: false,
+        internalType: "int8",
+        name: "decimals",
+        type: "int8",
+      },
+    ],
+    name: "FastUpdateFeedReset",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "votingEpochId",
+        type: "uint256",
+      },
+      {
+        indexed: false,
+        internalType: "uint256[]",
+        name: "feeds",
+        type: "uint256[]",
+      },
+      {
+        indexed: false,
+        internalType: "int8[]",
+        name: "decimals",
+        type: "int8[]",
+      },
+    ],
+    name: "FastUpdateFeeds",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint32",
+        name: "votingRoundId",
+        type: "uint32",
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "signingPolicyAddress",
+        type: "address",
+      },
+    ],
+    name: "FastUpdateFeedsSubmitted",
+    type: "event",
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_blockNum",
+        type: "uint256",
+      },
+    ],
+    name: "blockScoreCutoff",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "_cutoff",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "currentRewardEpochId",
+    outputs: [
+      {
+        internalType: "uint24",
+        name: "",
+        type: "uint24",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "currentScoreCutoff",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "_cutoff",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_signingPolicyAddress",
+        type: "address",
+      },
+    ],
+    name: "currentSortitionWeight",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "_weight",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "fetchAllCurrentFeeds",
+    outputs: [
+      {
+        internalType: "bytes21[]",
+        name: "_feedIds",
+        type: "bytes21[]",
+      },
+      {
+        internalType: "uint256[]",
+        name: "_feeds",
+        type: "uint256[]",
+      },
+      {
+        internalType: "int8[]",
+        name: "_decimals",
+        type: "int8[]",
+      },
+      {
+        internalType: "uint64",
+        name: "_timestamp",
+        type: "uint64",
+      },
+    ],
+    stateMutability: "payable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256[]",
+        name: "_indices",
+        type: "uint256[]",
+      },
+    ],
+    name: "fetchCurrentFeeds",
+    outputs: [
+      {
+        internalType: "uint256[]",
+        name: "_feeds",
+        type: "uint256[]",
+      },
+      {
+        internalType: "int8[]",
+        name: "_decimals",
+        type: "int8[]",
+      },
+      {
+        internalType: "uint64",
+        name: "_timestamp",
+        type: "uint64",
+      },
+    ],
+    stateMutability: "payable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_historySize",
+        type: "uint256",
+      },
+    ],
+    name: "numberOfUpdates",
+    outputs: [
+      {
+        internalType: "uint256[]",
+        name: "_noOfUpdates",
+        type: "uint256[]",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_blockNumber",
+        type: "uint256",
+      },
+    ],
+    name: "numberOfUpdatesInBlock",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "_noOfUpdates",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "submissionWindow",
+    outputs: [
+      {
+        internalType: "uint8",
+        name: "",
+        type: "uint8",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "sortitionBlock",
+            type: "uint256",
+          },
+          {
+            components: [
+              {
+                internalType: "uint256",
+                name: "replicate",
+                type: "uint256",
+              },
+              {
+                components: [
+                  {
+                    internalType: "uint256",
+                    name: "x",
+                    type: "uint256",
+                  },
+                  {
+                    internalType: "uint256",
+                    name: "y",
+                    type: "uint256",
+                  },
+                ],
+                internalType: "struct G1Point",
+                name: "gamma",
+                type: "tuple",
+              },
+              {
+                internalType: "uint256",
+                name: "c",
+                type: "uint256",
+              },
+              {
+                internalType: "uint256",
+                name: "s",
+                type: "uint256",
+              },
+            ],
+            internalType: "struct SortitionCredential",
+            name: "sortitionCredential",
+            type: "tuple",
+          },
+          {
+            internalType: "bytes",
+            name: "deltas",
+            type: "bytes",
+          },
+          {
+            components: [
+              {
+                internalType: "uint8",
+                name: "v",
+                type: "uint8",
+              },
+              {
+                internalType: "bytes32",
+                name: "r",
+                type: "bytes32",
+              },
+              {
+                internalType: "bytes32",
+                name: "s",
+                type: "bytes32",
+              },
+            ],
+            internalType: "struct IFastUpdater.Signature",
+            name: "signature",
+            type: "tuple",
+          },
+        ],
+        internalType: "struct IFastUpdater.FastUpdates",
+        name: "_updates",
+        type: "tuple",
+      },
+    ],
+    name: "submitUpdates",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+] as const;
+
+export class IFastUpdater__factory {
+  static readonly abi = _abi;
+  static createInterface(): IFastUpdaterInterface {
+    return new utils.Interface(_abi) as IFastUpdaterInterface;
+  }
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): IFastUpdater {
+    return new Contract(address, _abi, signerOrProvider) as IFastUpdater;
+  }
+}

typechain-types/factories/@flarenetwork/flare-periphery-contracts/coston2/IFastUpdatesConfiguration__factory.ts

@@ -0,0 +1,218 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+import { Contract, Signer, utils } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import type {
+  IFastUpdatesConfiguration,
+  IFastUpdatesConfigurationInterface,
+} from "../../../../@flarenetwork/flare-periphery-contracts/coston2/IFastUpdatesConfiguration";
+
+const _abi = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes21",
+        name: "feedId",
+        type: "bytes21",
+      },
+      {
+        indexed: false,
+        internalType: "uint32",
+        name: "rewardBandValue",
+        type: "uint32",
+      },
+      {
+        indexed: false,
+        internalType: "uint24",
+        name: "inflationShare",
+        type: "uint24",
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "index",
+        type: "uint256",
+      },
+    ],
+    name: "FeedAdded",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes21",
+        name: "feedId",
+        type: "bytes21",
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "index",
+        type: "uint256",
+      },
+    ],
+    name: "FeedRemoved",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes21",
+        name: "feedId",
+        type: "bytes21",
+      },
+      {
+        indexed: false,
+        internalType: "uint32",
+        name: "rewardBandValue",
+        type: "uint32",
+      },
+      {
+        indexed: false,
+        internalType: "uint24",
+        name: "inflationShare",
+        type: "uint24",
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "index",
+        type: "uint256",
+      },
+    ],
+    name: "FeedUpdated",
+    type: "event",
+  },
+  {
+    inputs: [],
+    name: "getFeedConfigurations",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "bytes21",
+            name: "feedId",
+            type: "bytes21",
+          },
+          {
+            internalType: "uint32",
+            name: "rewardBandValue",
+            type: "uint32",
+          },
+          {
+            internalType: "uint24",
+            name: "inflationShare",
+            type: "uint24",
+          },
+        ],
+        internalType: "struct IFastUpdatesConfiguration.FeedConfiguration[]",
+        name: "",
+        type: "tuple[]",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_index",
+        type: "uint256",
+      },
+    ],
+    name: "getFeedId",
+    outputs: [
+      {
+        internalType: "bytes21",
+        name: "_feedId",
+        type: "bytes21",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "getFeedIds",
+    outputs: [
+      {
+        internalType: "bytes21[]",
+        name: "",
+        type: "bytes21[]",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes21",
+        name: "_feedId",
+        type: "bytes21",
+      },
+    ],
+    name: "getFeedIndex",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "_index",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "getNumberOfFeeds",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "getUnusedIndices",
+    outputs: [
+      {
+        internalType: "uint256[]",
+        name: "",
+        type: "uint256[]",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+] as const;
+
+export class IFastUpdatesConfiguration__factory {
+  static readonly abi = _abi;
+  static createInterface(): IFastUpdatesConfigurationInterface {
+    return new utils.Interface(_abi) as IFastUpdatesConfigurationInterface;
+  }
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): IFastUpdatesConfiguration {
+    return new Contract(
+      address,
+      _abi,
+      signerOrProvider
+    ) as IFastUpdatesConfiguration;
+  }
+}

typechain-types/factories/@flarenetwork/flare-periphery-contracts/coston2/IFeeCalculator__factory.ts

@@ -0,0 +1,64 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+import { Contract, Signer, utils } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import type {
+  IFeeCalculator,
+  IFeeCalculatorInterface,
+} from "../../../../@flarenetwork/flare-periphery-contracts/coston2/IFeeCalculator";
+
+const _abi = [
+  {
+    inputs: [
+      {
+        internalType: "bytes21[]",
+        name: "_feedIds",
+        type: "bytes21[]",
+      },
+    ],
+    name: "calculateFeeByIds",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "_fee",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256[]",
+        name: "_indices",
+        type: "uint256[]",
+      },
+    ],
+    name: "calculateFeeByIndices",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "_fee",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+] as const;
+
+export class IFeeCalculator__factory {
+  static readonly abi = _abi;
+  static createInterface(): IFeeCalculatorInterface {
+    return new utils.Interface(_abi) as IFeeCalculatorInterface;
+  }
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): IFeeCalculator {
+    return new Contract(address, _abi, signerOrProvider) as IFeeCalculator;
+  }
+}

typechain-types/factories/@flarenetwork/flare-periphery-contracts/coston2/IFlareAssetRegistry__factory.ts

@@ -0,0 +1,256 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+import { Contract, Signer, utils } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import type {
+  IFlareAssetRegistry,
+  IFlareAssetRegistryInterface,
+} from "../../../../@flarenetwork/flare-periphery-contracts/coston2/IFlareAssetRegistry";
+
+const _abi = [
+  {
+    inputs: [],
+    name: "allAssetTypes",
+    outputs: [
+      {
+        internalType: "bytes32[]",
+        name: "",
+        type: "bytes32[]",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "allAssets",
+    outputs: [
+      {
+        internalType: "address[]",
+        name: "",
+        type: "address[]",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "_assetType",
+        type: "bytes32",
+      },
+    ],
+    name: "allAssetsOfType",
+    outputs: [
+      {
+        internalType: "address[]",
+        name: "",
+        type: "address[]",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "_assetType",
+        type: "bytes32",
+      },
+    ],
+    name: "allAssetsOfTypeWithSymbols",
+    outputs: [
+      {
+        internalType: "address[]",
+        name: "",
+        type: "address[]",
+      },
+      {
+        internalType: "string[]",
+        name: "",
+        type: "string[]",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "allAssetsWithSymbols",
+    outputs: [
+      {
+        internalType: "address[]",
+        name: "",
+        type: "address[]",
+      },
+      {
+        internalType: "string[]",
+        name: "",
+        type: "string[]",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "string",
+        name: "symbol",
+        type: "string",
+      },
+    ],
+    name: "assetBySymbol",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_token",
+        type: "address",
+      },
+    ],
+    name: "assetType",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "token",
+        type: "address",
+      },
+      {
+        internalType: "bytes32",
+        name: "nameHash",
+        type: "bytes32",
+      },
+    ],
+    name: "getAttribute",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "defined",
+        type: "bool",
+      },
+      {
+        internalType: "bytes32",
+        name: "value",
+        type: "bytes32",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "token",
+        type: "address",
+      },
+    ],
+    name: "incentivePoolFor",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "token",
+        type: "address",
+      },
+    ],
+    name: "isFlareAsset",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "token",
+        type: "address",
+      },
+    ],
+    name: "maxDelegatesByPercent",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "token",
+        type: "address",
+      },
+    ],
+    name: "supportsFtsoDelegation",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+] as const;
+
+export class IFlareAssetRegistry__factory {
+  static readonly abi = _abi;
+  static createInterface(): IFlareAssetRegistryInterface {
+    return new utils.Interface(_abi) as IFlareAssetRegistryInterface;
+  }
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): IFlareAssetRegistry {
+    return new Contract(address, _abi, signerOrProvider) as IFlareAssetRegistry;
+  }
+}